实现的所有接口

Serializable ， Appendable ， CharSequence ， Comparable<StringBuffer>
```
public final class StringBuffer
extends Object
implements Serializable, Comparable<StringBuffer>, CharSequence
```
线程安全，可变的字符序列。字符串缓冲区类似于String ，但可以进行修改。在任何时间点它都包含一些特定的字符序列，但序列的长度和内容可以通过某些方法调用来改变。
字符串缓冲区可供多个线程使用。这些方法在必要时进行同步，以便任何特定实例上的所有操作都表现得好像它们以某个串行顺序出现，这与所涉及的每个单独线程所进行的方法调用的顺序一致。

StringBuffer上的主要操作是append和insert方法，它们被重载以接受任何类型的数据。每个都有效地将给定的数据转换为字符串，然后将该字符串的字符追加或插入字符串缓冲区。 append方法总是在缓冲区的末尾添加这些字符; insert方法在指定点添加字符。

例如，如果z引用其当前内容为"start"的字符串缓冲区对象，则方法调用z.append("le")将导致字符串缓冲区包含"startle" ，而z.insert(4, "le")将更改字符串缓冲区以包含"starlet" 。

一般情况下，如果某人是指的一个实例StringBuffer ，然后sb.append(x)具有相同的效果sb.insert(sb.length(), x) 。

每当涉及源序列的操作发生时（例如从源序列追加或插入），此类仅在执行操作的字符串缓冲区上同步，而不在源上同步。请注意，虽然StringBuffer设计为可以安全地从多个线程同时使用，但如果构造函数或append或insert操作传递了跨线程共享的源序列，则调用代码必须确保操作具有一致且不变的视图操作持续时间的源序列。这可以通过在操作调用期间持有锁的调用者，通过使用不可变的源序列，或者不跨线程共享源序列来满足。

每个字符串缓冲区都有容量。只要字符串缓冲区中包含的字符序列的长度不超过容量，就不必分配新的内部缓冲区数组。如果内部缓冲区溢出，它会自动变大。

除非另有说明，否则将null参数传递给null中的构造函数或方法将导致抛出NullPointerException 。

从JDK 5版本开始，这个类已经补充了一个设计用于单个线程的等效类， StringBuilder 。通常应优先使用StringBuilder类，因为它支持所有相同的操作，但速度更快，因为它不执行同步。

API Note:

StringBuffer实现Comparable但不覆盖equals 。因此， StringBuffer的自然顺序与equals不一致。如果StringBuffer对象用作StringBuffer中的键或SortedMap元素， SortedSet 。见Comparable ， SortedMap ，或SortedSet获取更多信息。

从以下版本开始：

1.0

另请参见：

StringBuilder ， String ， Serialized Form

构造方法摘要

构造方法
构造器	描述
`StringBuffer()`	构造一个字符串缓冲区，其中没有字符，初始容量为16个字符。
`StringBuffer(int capacity)`	构造一个字符串缓冲区，其中没有字符和指定的初始容量。
`StringBuffer(CharSequence seq)`	构造一个字符串缓冲区，其中包含与指定的 `CharSequence`相同的字符。
`StringBuffer(String str)`	构造一个初始化为指定字符串内容的字符串缓冲区。

方法摘要

所有方法实例方法具体的方法
变量和类型	方法	描述
`StringBuffer`	`append(boolean b)`	将 `boolean`参数的字符串表示形式追加到序列中。
`StringBuffer`	`append(char c)`	将 `char`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(char[] str)`	将 `char`数组参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(char[] str, int offset, int len)`	将 `char`数组参数的子数组的字符串表示形式追加到此序列。
`StringBuffer`	`append(double d)`	将 `double`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(float f)`	将 `float`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(int i)`	将 `int`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(long lng)`	将 `long`参数的字符串表示形式追加到此序列。
`StringBuffer`	`append(CharSequence s)`	将指定的 `CharSequence`追加到此序列。
`StringBuffer`	`append(CharSequence s, int start, int end)`	将指定的 `CharSequence`序列附加到此序列。
`StringBuffer`	`append(Object obj)`	追加 `Object`参数的字符串表示形式。
`StringBuffer`	`append(String str)`	将指定的字符串追加到此字符序列。
`StringBuffer`	`append(StringBuffer sb)`	将指定的 `StringBuffer`追加到此序列。
`StringBuffer`	`appendCodePoint(int codePoint)`	将 `codePoint`参数的字符串表示形式追加到此序列。
`int`	`capacity()`	返回当前容量。
`char`	`charAt(int index)`	返回指定索引处的此序列中的 `char`值。
`IntStream`	`chars()`	返回 `int`的流，对此序列中的 `char`值进行零扩展。
`int`	`codePointAt(int index)`	返回指定索引处的字符（Unicode代码点）。
`int`	`codePointBefore(int index)`	返回指定索引之前的字符（Unicode代码点）。
`int`	`codePointCount(int beginIndex, int endIndex)`	返回此序列的指定文本范围内的Unicode代码点数。
`IntStream`	`codePoints()`	返回此序列中的代码点值流。
`int`	`compareTo(StringBuffer another)`	`StringBuffer`字典顺序比较两个 `StringBuffer`实例。
`StringBuffer`	`delete(int start, int end)`	删除此序列的子字符串中的字符。
`StringBuffer`	`deleteCharAt(int index)`	按此顺序删除指定位置的 `char` 。
`void`	`ensureCapacity(int minimumCapacity)`	确保容量至少等于指定的最小值。
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)`	将字符从此序列复制到目标字符数组 `dst` 。
`int`	`indexOf(String str)`	返回指定子字符串第一次出现的字符串中的索引。
`int`	`indexOf(String str, int fromIndex)`	从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
`StringBuffer`	`insert(int offset, boolean b)`	将 `boolean`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, char c)`	将 `char`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, char[] str)`	将 `char`数组参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int index, char[] str, int offset, int len)`	将 `str`数组参数的子数组的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, double d)`	将 `double`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, float f)`	将 `float`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int offset, int i)`	将第二个 `int`参数的字符串表示形式插入到此序列中。
`StringBuffer`	`insert(int offset, long l)`	将 `long`参数的字符串表示形式插入此序列中。
`StringBuffer`	`insert(int dstOffset, CharSequence s)`	将指定的 `CharSequence`插入此序列。
`StringBuffer`	`insert(int dstOffset, CharSequence s, int start, int end)`	将指定的 `CharSequence`序列插入此序列。
`StringBuffer`	`insert(int offset, Object obj)`	将 `Object`参数的字符串表示形式插入此字符序列。
`StringBuffer`	`insert(int offset, String str)`	将字符串插入此字符序列。
`int`	`lastIndexOf(String str)`	返回指定子字符串最后一次出现的字符串中的索引。
`int`	`lastIndexOf(String str, int fromIndex)`	返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。
`int`	`offsetByCodePoints(int index, int codePointOffset)`	返回此序列中的索引，该索引从给定的 `index`偏移 `codePointOffset`代码点。
`StringBuffer`	`replace(int start, int end, String str)`	使用指定的 `String`的字符替换此序列的子字符串中的字符。
`StringBuffer`	`reverse()`	导致此字符序列被序列的反向替换。
`void`	`setCharAt(int index, char ch)`	指定索引处的字符设置为 `ch` 。
`void`	`setLength(int newLength)`	设置字符序列的长度。
`CharSequence`	`subSequence(int start, int end)`	返回一个新的字符序列，它是该序列的子序列。
`String`	`substring(int start)`	返回一个新的 `String` ，其中包含此字符序列中当前包含的字符的子序列。
`String`	`substring(int start, int end)`	返回一个新的 `String` ，其中包含当前包含在此序列中的字符的子序列。
`void`	`trimToSize()`	尝试减少用于字符序列的存储空间。

声明方法的类 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

声明方法的接口 java.lang.CharSequence
chars, codePoints, length, toString

- 构造方法详细信息
  - StringBuffer
```
public StringBuffer()
```
    构造一个字符串缓冲区，其中没有字符，初始容量为16个字符。
  - StringBuffer
```
public StringBuffer(int capacity)
```
    构造一个字符串缓冲区，其中没有字符和指定的初始容量。
    
    参数
    
    capacity - 初始容量。
    
    异常
    
    NegativeArraySizeException - 如果 capacity参数小于 0 。
  - StringBuffer
```
public StringBuffer(String str)
```
    构造一个初始化为指定字符串内容的字符串缓冲区。字符串缓冲区的初始容量是16加上字符串参数的长度。
    
    参数
    
    str - 缓冲区的初始内容。
  - StringBuffer
```
public StringBuffer(CharSequence seq)
```
    构造一个字符串缓冲区，其中包含与指定的CharSequence相同的字符。字符串缓冲区的初始容量为16加上CharSequence参数的长度。
    如果指定的CharSequence的长度小于或等于零，则返回容量为16的空缓冲区。
    
    参数
    
    seq - 要复制的序列。
    
    从以下版本开始：
    
    1.5
- 方法详细信息
  - compareTo
```
public int compareTo(StringBuffer another)
```
    StringBuffer字典顺序比较两个StringBuffer实例。该方法遵循CharSequence.compare(this, another)方法中定义的词典比较的相同规则。
    有关细粒度，区域设置敏感的String比较，请参阅Collator 。
    
    Specified by:
    
    compareTo ，界面 Comparable<StringBuffer>
    
    Implementation Note:
    
    此方法在 this （当前对象）上同步，但不与 this StringBuffer进行同步，而 StringBuffer another与 this StringBuffer进行比较。
    
    参数
    
    another - StringBuffer比较的 StringBuffer
    
    结果
    
    值0如果此StringBuffer包含与参数StringBuffer相同的字符序列; 如果此StringBuffer在字典上小于StringBuffer参数， StringBuffer负整数; 如果此StringBuffer在字典上大于StringBuffer参数， StringBuffer正整数。
    
    从以下版本开始：
    
    11
  - capacity
```
public int capacity()
```
    返回当前容量。容量是新插入字符可用的存储量，超出该容量将进行分配。
    
    结果
    
    目前的能力
  - ensureCapacity
```
public void ensureCapacity(int minimumCapacity)
```
    确保容量至少等于指定的最小值。如果当前容量小于参数，则分配具有更大容量的新内部阵列。新容量是更大的：
    
    minimumCapacity论点。
    
    旧容量的两倍，再加上2 。
    
    如果minimumCapacity参数为非正数，则此方法不执行任何操作，只返回。请注意，对此对象的后续操作可以将实际容量降低到此处请求的容量以下。
    参数
    
    minimumCapacity - 所需的最小容量。
  - trimToSize
```
public void trimToSize()
```
    尝试减少用于字符序列的存储空间。如果缓冲区大于保持其当前字符序列所需的缓冲区，则可以调整其大小以使空间效率更高。调用此方法可能（但不是必须）影响后续调用capacity()方法返回的值。
    
    从以下版本开始：
    
    1.5
  - setLength
```
public void setLength(int newLength)
```
    设置字符序列的长度。序列更改为新的字符序列，其长度由参数指定。对于小于每非负索引k newLength ，在新的字符序列的索引k处的字符是相同的在旧序列索引k如果k小于原字符序列的长度的字符; 否则，它是空字符'\u0000' 。换句话说，如果newLength参数小于当前长度，则长度将更改为指定的长度。
    如果newLength参数大于或等于当前长度，则会附加足够的空字符（ '\u0000' ），以便length成为newLength参数。
    
    newLength参数必须大于或等于0 。
    
    参数
    
    newLength - 新长度
    
    异常
    
    IndexOutOfBoundsException - 如果 newLength参数为负数。
    
    另请参见：
    
    CharSequence.length()
  - charAt
```
public char charAt(int index)
```
    返回指定索引处的此序列中的char值。第一个char值位于索引0 ，下一个位于索引1 ，依此类推，如数组索引中所示。
    index参数必须大于或等于0 ，并且小于此序列的长度。
    
    如果索引指定的char值为surrogate ，则返回代理值。
    
    Specified by:
    
    charAt在界面 CharSequence
    
    参数
    
    index - 所需 char值的索引。
    
    结果
    
    指定索引处的 char值。
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或大于或等于 length() 。
    
    另请参见：
    
    CharSequence.length()
  - codePointAt
```
public int codePointAt(int index)
```
    返回指定索引处的字符（Unicode代码点）。索引引用char值（Unicode代码单位），范围从0到CharSequence.length() - 1 。
    如果在给定索引处指定的char值处于高代理范围内，则以下索引小于此序列的长度，并且以下索引处的char值处于低代理范围，然后是补充代码点对应于此代理项对返回。否则，返回给定索引处的char值。
    
    参数
    
    index - char值的索引
    
    结果
    
    index处字符的代码点值
    
    异常
    
    IndexOutOfBoundsException - 如果 index参数为负数或不小于此序列的长度。
    
    从以下版本开始：
    
    1.5
  - codePointBefore
```
public int codePointBefore(int index)
```
    返回指定索引之前的字符（Unicode代码点）。索引引用char值（Unicode代码单位），范围从1到CharSequence.length() 。
    如果char在值(index - 1)处于低代理项范围， (index - 2)不为负，并且char在值(index - 2)处于高代理项范围，则返回代理对的补充代码点值。如果char在值index - 1是未配对的低代理或一个高代理，则返回所述替代值。
    
    参数
    
    index - 应返回的代码点后面的索引
    
    结果
    
    给定索引之前的Unicode代码点值。
    
    异常
    
    IndexOutOfBoundsException - 如果 index参数小于1或大于此序列的长度。
    
    从以下版本开始：
    
    1.5
  - codePointCount
```
public int codePointCount(int beginIndex,
                          int endIndex)
```
    返回此序列的指定文本范围内的Unicode代码点数。文本范围开始在指定的beginIndex ，并延伸到char在索引endIndex - 1 。因此，文本范围的长度（在char s中）是endIndex-beginIndex 。此序列中的未配对代理计为每个代码点。
    
    参数
    
    beginIndex - 文本范围的第一个 char的索引。
    
    endIndex - 文本范围的最后 char之后的索引。
    
    结果
    
    指定文本范围内的Unicode代码点数
    
    异常
    
    IndexOutOfBoundsException - 如果 beginIndex为负数，或者 endIndex大于此序列的长度，或者 beginIndex大于 endIndex 。
    
    从以下版本开始：
    
    1.5
  - offsetByCodePoints
```
public int offsetByCodePoints(int index,
                              int codePointOffset)
```
    返回此序列中的索引，该索引从给定的index偏移codePointOffset代码点。 index和codePointOffset给出的文本范围内的未配对代理计为每个代码点。
    
    参数
    
    index - 要偏移的索引
    
    codePointOffset - 代码点中的偏移量
    
    结果
    
    此序列中的索引
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负或大于此序列的长度，或者如果 codePointOffset为正且从 index开始的子 codePointOffset代码点少于 codePointOffset ，或者 codePointOffset为负且 index之前的子 index小于绝对值的绝对值 codePointOffset代码点。
    
    从以下版本开始：
    
    1.5
  - getChars
```
public void getChars(int srcBegin,
                     int srcEnd,
                     char[] dst,
                     int dstBegin)
```
    将字符从此序列复制到目标字符数组dst 。要复制的第一个字符是索引srcBegin ; 要复制的最后一个字符位于索引srcEnd-1 。要复制的字符总数为srcEnd-srcBegin 。字符被复制到dst的子阵列中，从索引dstBegin开始并以索引结束：
    dstbegin + (srcEnd-srcBegin) - 1
    参数
    
    srcBegin - 以此偏移量开始复制。
    
    srcEnd - 停止在此偏移处复制。
    
    dst - 要将数据复制到的数组。
    
    dstBegin - 抵消到 dst 。
    
    异常
    
    IndexOutOfBoundsException - 如果满足以下任何条件：
    
    srcBegin是否定的
    
    dstBegin是否定的
    
    srcBegin参数大于srcEnd参数。
    
    srcEnd大于this.length() 。
    
    dstBegin+srcEnd-srcBegin大于dst.length
  - setCharAt
```
public void setCharAt(int index,
                      char ch)
```
    指定索引处的字符设置为ch 。该序列被改变以表示一个新的字符序列，其是相同的原字符序列，不同之处在于它包含字符ch在位置index 。
    index参数必须大于或等于0 ，并且小于此序列的长度。
    
    参数
    
    index - 要修改的字符的索引。
    
    ch - 新角色。
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或大于或等于 length() 。
    
    另请参见：
    
    CharSequence.length()
  - append
```
public StringBuffer append(Object obj)
```
    追加Object参数的字符串表示形式。
    整体效果与通过方法String.valueOf(Object)将参数转换为字符串完全相同，并且该字符串的字符随后是appended到此字符序列。
    
    参数
    
    obj - Object 。
    
    结果
    
    对此对象的引用。
  - append
```
public StringBuffer append(String str)
```
    将指定的字符串追加到此字符序列。
    String参数的字符按顺序附加，按参数的长度增加此序列的长度。如果str是null ，则附加四个字符"null" 。
    
    设n是执行append方法之前的该字符序列的长度。如果k小于n ，则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则，它等于参数str中索引kn处的字符。
    
    参数
    
    str - 一个字符串。
    
    结果
    
    对此对象的引用。
  - append
```
public StringBuffer append(StringBuffer sb)
```
    将指定的StringBuffer追加到此序列。
    所述的字符StringBuffer参数附加，为了，该内容StringBuffer ，增加该的长度StringBuffer由参数的长度。如果sb是null ，则四个字符"null"将附加到此StringBuffer 。
    
    令n为旧字符序列的长度，即在执行append方法之前StringBuffer包含的字符序列的长度。如果k小于n ，则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则，它等于参数sb中索引kn处的字符。
    
    此方法在目标对象this同步，但不在源上同步（ sb ）。
    
    参数
    
    sb - 要追加的 StringBuffer 。
    
    结果
    
    对此对象的引用。
    
    从以下版本开始：
    
    1.4
  - append
```
public StringBuffer append(CharSequence s)
```
    将指定的CharSequence追加到此序列。
    CharSequence参数的字符按顺序附加，按参数的长度增加此序列的长度。
    
    这个方法的结果与调用this.append（s，0，s.length（））完全相同;
    
    此方法在目标对象this同步，但不在源上同步（ s ）。
    
    如果s是null ，则附加四个字符"null" 。
    
    Specified by:
    
    append接口 Appendable
    
    参数
    
    s - 要追加的 CharSequence 。
    
    结果
    
    对此对象的引用。
    
    从以下版本开始：
    
    1.5
  - append
```
public StringBuffer append(CharSequence s,
                           int start,
                           int end)
```
    将指定的CharSequence序列追加到此序列。
    从索引start开始的参数s字符按顺序附加到该序列的内容，直到（不包括）索引end 。该序列的长度增加了end - start的值。
    
    设n是执行append方法之前的该字符序列的长度。然后，如果k小于n ，则该字符序列中索引k处的字符变为等于该序列中索引k处的字符; 否则，它等于参数s中索引k + start-n处的s 。
    
    如果s是null ，则此方法附加字符，就好像s参数是包含四个字符"null"的序列"null" 。
    
    Specified by:
    
    append在接口 Appendable
    
    参数
    
    s - 要追加的序列。
    
    start - 要追加的子序列的起始索引。
    
    end - 要追加的子序列的结束索引。
    
    结果
    
    对此对象的引用。
    
    异常
    
    IndexOutOfBoundsException - 如果 start为负数，或 start大于 end或 end大于 s.length()
    
    从以下版本开始：
    
    1.5
  - append
```
public StringBuffer append(char[] str)
```
    将char数组参数的字符串表示形式追加到此序列。
    数组参数的字符按顺序附加到此序列的内容中。该序列的长度增加了参数的长度。
    
    整体效果就像通过方法String.valueOf(char[])将参数转换为字符串一样，并且该字符串的字符随后是appended到此字符序列。
    
    参数
    
    str - 要追加的字符。
    
    结果
    
    对此对象的引用。
  - append
```
public StringBuffer append(char[] str,
                           int offset,
                           int len)
```
    将char数组参数的子数组的字符串表示形式追加到此序列。
    从索引offset开始的char阵列str字符按顺序附加到该序列的内容。此序列的长度增加值len 。
    
    整体效果就像通过方法String.valueOf(char[],int,int)将参数转换为字符串一样，并且该字符串的字符随后是appended到此字符序列。
    
    参数
    
    str - 要追加的字符。
    
    offset - 要追加的第一个 char的索引。
    
    len - 要追加的 char s的数量。
    
    结果
    
    对此对象的引用。
    
    异常
    
    IndexOutOfBoundsException - 如果是 offset < 0或 len < 0或 offset+len > str.length
  - append
```
public StringBuffer append(boolean b)
```
    将boolean参数的字符串表示形式追加到序列中。
    整体效果与通过方法String.valueOf(boolean)将参数转换为字符串完全相同，并且该字符串的字符随后是appended到此字符序列。
    
    参数
    
    b - a boolean 。
    
    结果
    
    对此对象的引用。
  - append
```
public StringBuffer append(char c)
```
    将char参数的字符串表示形式追加到此序列。
    该参数附加到此序列的内容中。此序列的长度增加1 。
    
    整体效果与方法String.valueOf(char)将参数转换为字符串完全相同，然后该字符串中的字符为appended 。
    
    Specified by:
    
    append在接口 Appendable
    
    参数
    
    c - a char 。
    
    结果
    
    对此对象的引用。
  - append
```
public StringBuffer append(int i)
```
    将int参数的字符串表示形式追加到此序列。
    整体效果就像通过方法String.valueOf(int)将参数转换为字符串一样，并且该字符串的字符随后是appended到此字符序列。
    
    参数
    
    i - int 。
    
    结果
    
    对此对象的引用。
  - appendCodePoint
```
public StringBuffer appendCodePoint(int codePoint)
```
    将codePoint参数的字符串表示形式追加到此序列。
    该参数附加到此序列的内容中。该序列的长度增加Character.charCount(codePoint) 。
    
    整体效果与通过方法Character.toChars(int)将参数转换为char数组完全相同，并且该数组中的字符随后是appended到此字符序列。
    
    参数
    
    codePoint - Unicode代码点
    
    结果
    
    对此对象的引用。
    
    从以下版本开始：
    
    1.5
  - append
```
public StringBuffer append(long lng)
```
    将long参数的字符串表示形式追加到此序列。
    整体效果与通过方法String.valueOf(long)将参数转换为字符串完全相同，然后该字符串的字符为该字符序列的appended 。
    
    参数
    
    lng - a long 。
    
    结果
    
    对此对象的引用。
  - append
```
public StringBuffer append(float f)
```
    将float参数的字符串表示形式追加到此序列。
    整体效果与通过方法String.valueOf(float)将参数转换为字符串完全相同，然后该字符串的字符为该字符序列的appended 。
    
    参数
    
    f - a float 。
    
    结果
    
    对此对象的引用。
  - append
```
public StringBuffer append(double d)
```
    将double参数的字符串表示形式追加到此序列。
    整体效果与方法String.valueOf(double)将参数转换为字符串完全相同，然后该字符串的字符为appended 。
    
    参数
    
    d - a double 。
    
    结果
    
    对此对象的引用。
  - delete
```
public StringBuffer delete(int start,
                           int end)
```
    删除此序列的子字符串中的字符。子字符串从指定的start开始，如果不存在这样的字符，则扩展到索引end - 1处的字符或序列的末尾。如果start等于end ，则不进行任何更改。
    
    参数
    
    start - 起始索引，包括。
    
    end - 结束索引，不包括。
    
    结果
    
    这个对象。
    
    异常
    
    StringIndexOutOfBoundsException - 如果 start为负数，大于 length() ，或大于 end 。
    
    从以下版本开始：
    
    1.2
  - deleteCharAt
```
public StringBuffer deleteCharAt(int index)
```
    按此顺序删除指定位置的char 。此序列由一个char缩短。
    注意：如果给定索引处的字符是补充字符，则此方法不会删除整个字符。如果需要的准确处理增补字符，确定数量char通过调用删除Character.charCount(thisSequence.codePointAt(index)) ，其中thisSequence为这个序列。
    
    参数
    
    index - 要删除的索引号 char
    
    结果
    
    这个对象。
    
    异常
    
    StringIndexOutOfBoundsException - 如果 index为负数或大于或等于 length() 。
    
    从以下版本开始：
    
    1.2
  - replace
```
public StringBuffer replace(int start,
                            int end,
                            String str)
```
    使用指定的String的字符替换此序列的子字符串中的字符。子字符串从指定的start开始，并且如果不存在这样的字符，则扩展到索引end - 1处的字符或序列的末尾。首先删除子字符串中的字符，然后在String插入指定的start 。（如果需要，将延长此序列以容纳指定的字符串。）
    
    参数
    
    start - 起始索引，包括在内。
    
    end - 结束索引，不包括。
    
    str - 将替换先前内容的字符串。
    
    结果
    
    这个对象。
    
    异常
    
    StringIndexOutOfBoundsException - 如果 start为负数，大于 length() ，或大于 end 。
    
    从以下版本开始：
    
    1.2
  - substring
```
public String substring(int start)
```
    返回一个新的String ，其中包含此字符序列中当前包含的字符的子序列。子字符串从指定的索引开始并延伸到此序列的末尾。
    
    参数
    
    start - 起始索引，包括在内。
    
    结果
    
    新的字符串。
    
    异常
    
    StringIndexOutOfBoundsException - 如果 start小于零，或大于此对象的长度。
    
    从以下版本开始：
    
    1.2
  - subSequence
```
public CharSequence subSequence(int start,
                                int end)
```
    返回一个新的字符序列，它是该序列的子序列。
    调用此方法的形式
    
    sb.subSequence(begin, end)
    行为与调用完全相同
    sb.substring(begin, end)
    提供此方法是为了使该类可以实现CharSequence接口。
    Specified by:
    
    subSequence ，界面 CharSequence
    
    参数
    
    start - 起始索引，包括。
    
    end - 结束索引，独家。
    
    结果
    
    指定的子序列。
    
    异常
    
    IndexOutOfBoundsException - 如果 start或 end为负数，如果 end大于 length() ，或者 start大于 end
    
    从以下版本开始：
    
    1.4
  - substring
```
public String substring(int start,
                        int end)
```
    返回一个新的String ，其中包含当前包含在此序列中的字符的子序列。子字符串从指定的start开始，并扩展到索引end - 1处的字符。
    
    参数
    
    start - 起始索引，包括。
    
    end - 结束索引，独占。
    
    结果
    
    新的字符串。
    
    异常
    
    StringIndexOutOfBoundsException - 如果 start或 end为负数或大于 length() ，或 start大于 end 。
    
    从以下版本开始：
    
    1.2
  - insert
```
public StringBuffer insert(int index,
                           char[] str,
                           int offset,
                           int len)
```
    将str数组参数的子数组的字符串表示形式插入到此序列中。该子阵列从指定的offset开始，并扩展到len char s。子阵列的字符在index指示的位置插入该序列中。该序列的长度增加len char s。
    
    参数
    
    index - 插入子阵列的位置。
    
    str - A char阵列。
    
    offset - 要插入的子阵列中的第一个 char的索引。
    
    len - 要插入的子阵列中的 char s的数量。
    
    结果
    
    这个对象
    
    异常
    
    StringIndexOutOfBoundsException - 如果 index为负数或大于 length() ，或 offset或 len为负数，或 (offset+len)大于 str.length 。
    
    从以下版本开始：
    
    1.2
  - insert
```
public StringBuffer insert(int offset,
                           Object obj)
```
    将Object参数的字符串表示形式插入此字符序列中。
    整体效果与通过方法String.valueOf(Object)将第二个参数转换为字符串完全相同，然后该字符串的字符在指定的偏移量处进入该字符序列inserted 。
    
    offset参数必须大于或等于0 ，且小于或等于此序列的length 。
    
    参数
    
    offset - 偏移量。
    
    obj - Object 。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int offset,
                           String str)
```
    将字符串插入此字符序列。
    String参数的字符按顺序插入到指定偏移量的此序列中，向上移动最初位于该位置上方的任何字符，并将该序列的长度增加参数的长度。如果str是null ，则将四个字符"null"插入到该序列中。
    
    新字符序列中索引k处的字符等于：
    
    如果k小于offset ，则旧字符序列中索引k处的字符
    
    参数str中索引为k -offset的字符，如果k不小于offset但小于offset+str.length()
    
    旧字符序列中索引为k -str.length()的字符，如果k不小于offset+str.length()
    
    offset参数必须大于或等于0 ，且小于或等于此序列的length 。
    参数
    
    offset - 偏移量。
    
    str - 一个字符串。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int offset,
                           char[] str)
```
    将char数组参数的字符串表示形式插入此序列中。
    数组参数的字符在offset指示的位置插入该序列的内容中。该序列的长度增加了参数的长度。
    
    整体效果与通过方法String.valueOf(char[])将第二个参数转换为字符串完全相同，然后该字符串的字符在指定的偏移量处进入该字符序列inserted 。
    
    offset参数必须大于或等于0 ，且小于或等于此序列的length 。
    
    参数
    
    offset - 偏移量。
    
    str - 字符数组。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int dstOffset,
                           CharSequence s)
```
    将指定的CharSequence插入此序列。
    CharSequence参数的字符按顺序插入到指定偏移量的此序列中，向上移动最初位于该位置上方的任何字符，并将该序列的长度增加参数s的长度。
    
    此方法的结果与调用此对象的insert （dstOffset，s，0，s.length（））方法完全相同。
    
    如果s是null ，则将四个字符"null"插入到该序列中。
    
    参数
    
    dstOffset - 偏移量。
    
    s - 要插入的序列
    
    结果
    
    对此对象的引用。
    
    异常
    
    IndexOutOfBoundsException - 如果偏移无效。
    
    从以下版本开始：
    
    1.5
  - insert
```
public StringBuffer insert(int dstOffset,
                           CharSequence s,
                           int start,
                           int end)
```
    将指定的CharSequence序列插入此序列。
    参数的子序列s通过指定start和end被插入，以便成在指定的目的地偏移该序列中，该位置上述最初向上运动的任何字符。该序列的长度增加了end - start 。
    
    此序列中索引k处的字符变为等于：
    
    如果k小于dstOffset ，则此序列中索引k处的字符
    
    参数s中索引为k +start-dstOffset的字符，如果k大于或等于dstOffset但小于dstOffset+end-start
    
    如果k大于或等于dstOffset+end-start ，则此序列中索引为k -(end-start)的字符
    
    dstOffset参数必须大于或等于0 ，且小于或等于此序列的length 。
    
    start参数必须是非负的，且不大于end 。
    
    结束参数必须大于或等于start ，并且小于或等于s的长度。
    
    如果s是null ，则此方法插入字符，就好像s参数是包含四个字符"null"的序列"null" 。
    参数
    
    dstOffset - 此序列中的偏移量。
    
    s - 要插入的序列。
    
    start - 要插入的子序列的起始索引。
    
    end - 要插入的子序列的结束索引。
    
    结果
    
    对此对象的引用。
    
    异常
    
    IndexOutOfBoundsException - 如果 dstOffset为负数或大于 this.length() ，或 start或 end为负数，或 start大于 end或 end大于 s.length()
    
    从以下版本开始：
    
    1.5
  - insert
```
public StringBuffer insert(int offset,
                           boolean b)
```
    将boolean参数的字符串表示形式插入此序列中。
    整体效果与通过方法String.valueOf(boolean)将第二个参数转换为字符串完全相同，然后该字符串的字符在指定的偏移量处进入该字符序列inserted 。
    
    offset参数必须大于或等于0 ，并且小于或等于此序列的length 。
    
    参数
    
    offset - 偏移量。
    
    b - a boolean 。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int offset,
                           char c)
```
    将char参数的字符串表示形式插入此序列中。
    整体效果与通过方法String.valueOf(char)将第二个参数转换为字符串完全相同，然后该字符串中的字符在指定的偏移量处进入该字符序列inserted 。
    
    offset参数必须大于或等于0 ，并且小于或等于此序列的length 。
    
    参数
    
    offset - 抵消。
    
    c - a char 。
    
    结果
    
    对此对象的引用。
    
    异常
    
    IndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int offset,
                           int i)
```
    将第二个int参数的字符串表示形式插入此序列中。
    整体效果与通过方法String.valueOf(int)将第二个参数转换为字符串完全相同，然后该字符串的字符在指定的偏移量处进入该字符序列inserted 。
    
    offset参数必须大于或等于0 ，并且小于或等于此序列的length 。
    
    参数
    
    offset - 偏移量。
    
    i - int 。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int offset,
                           long l)
```
    将long参数的字符串表示形式插入此序列中。
    整体效果与通过方法String.valueOf(long)将第二个参数转换为字符串完全相同，然后该字符串的字符在指定的偏移量处进入该字符序列inserted 。
    
    offset参数必须大于或等于0 ，并且小于或等于此序列的length 。
    
    参数
    
    offset - 抵消。
    
    l - a long 。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int offset,
                           float f)
```
    将float参数的字符串表示形式插入此序列中。
    整体效果与通过方法String.valueOf(float)将第二个参数转换为字符串完全相同，然后该字符串的字符在指定的偏移量处进入该字符序列inserted 。
    
    offset参数必须大于或等于0 ，并且小于或等于此序列的length 。
    
    参数
    
    offset - 偏移量。
    
    f - a float 。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuffer insert(int offset,
                           double d)
```
    将double参数的字符串表示形式插入此序列中。
    整体效果与通过方法String.valueOf(double)将第二个参数转换为字符串完全相同，然后该字符串的字符在指定的偏移量处进入该字符序列的inserted 。
    
    offset参数必须大于或等于0 ，并且小于或等于此序列的length 。
    
    参数
    
    offset - 抵消。
    
    d - a double 。
    
    结果
    
    对此对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - indexOf
```
public int indexOf(String str)
```
    返回指定子字符串第一次出现的字符串中的索引。
    返回的索引是最小值k ，其中：
    
    this.toString().startsWith(str, k)
    如果没有这样的价值k存在，那么-1返回。
    参数
    
    str - 要搜索的子字符串。
    
    结果
    
    指定子字符串第一次出现的索引，如果没有这种情况， -1 。
    
    从以下版本开始：
    
    1.4
  - indexOf
```
public int indexOf(String str,
                   int fromIndex)
```
    从指定的索引处开始，返回指定子字符串第一次出现的字符串中的索引。
    返回的索引是最小值k ，其中：
    
    k >= Math.min(fromIndex, this.length()) && this.toString().startsWith(str, k)
    如果没有这样的价值k存在，那么-1返回。
    参数
    
    str - 要搜索的子字符串。
    
    fromIndex - 从中开始搜索的索引。
    
    结果
    
    从指定索引开始的指定子字符串第一次出现的索引，如果没有这种情况 -1 。
    
    从以下版本开始：
    
    1.4
  - lastIndexOf
```
public int lastIndexOf(String str)
```
    返回指定子字符串最后一次出现的字符串中的索引。最后出现的空字符串“”被认为发生在索引值this.length() 。
    返回的索引是最大值k ，其中：
    
    this.toString().startsWith(str, k)
    如果没有这样的价值k存在，那么-1返回。
    参数
    
    str - 要搜索的子字符串。
    
    结果
    
    指定子字符串最后一次出现的索引，如果没有这种情况， -1 。
    
    从以下版本开始：
    
    1.4
  - lastIndexOf
```
public int lastIndexOf(String str,
                       int fromIndex)
```
    返回指定子字符串最后一次出现的字符串中的索引，从指定索引开始向后搜索。
    返回的索引是最大值k ，其中：
    
    k <= Math.min(fromIndex, this.length()) && this.toString().startsWith(str, k)
    如果没有这样的价值k存在，那么-1返回。
    参数
    
    str - 要搜索的子字符串。
    
    fromIndex - 从中开始搜索的索引。
    
    结果
    
    指定子字符串最后一次出现的索引，从指定索引向后搜索，如果没有这种情况 -1搜索。
    
    从以下版本开始：
    
    1.4
  - reverse
```
public StringBuffer reverse()
```
    导致此字符序列被序列的反向替换。如果序列中包含任何代理对，则将这些代理对视为反向操作的单个字符。因此，高低代理人的顺序永远不会逆转。设n是执行reverse方法之前的该字符序列的字符长度（不是char值中的长度）。然后，新字符序列中索引k处的字符等于旧字符序列中索引nk-1处的字符。
    请注意，反向操作可能导致产生代理对，这些代理对在操作之前是不成对的低代理和高代理。例如，反转“\ uDC00 \ uD800”会生成“\ uD800 \ uDC00”，这是一个有效的代理项对。
    
    结果
    
    对此对象的引用。
    
    从以下版本开始：
    
    1.0.2
  - chars
```
public IntStream chars()
```
    返回int的流，对此序列中的char值进行零扩展。映射到surrogate code point的任何字符都是未解释的。
    当终端流操作开始时，流绑定到该序列（具体地，对于可变序列，流的分裂器是late-binding ）。如果在该操作期间修改了序列，则结果是未定义的。
    
    Specified by:
    
    chars在接口 CharSequence
    
    结果
    
    来自此序列的char值的IntStream
    
    从以下版本开始：
    
    9
  - codePoints
```
public IntStream codePoints()
```
    返回此序列中的代码点值流。序列中遇到的任何代理对被组合，就像Character.toCodePoint一样，结果传递给流。任何其他代码单元（包括普通BMP字符，未配对代理项和未定义代码单元）将零扩展为int值，然后传递给流。
    当终端流操作开始时，流与该序列结合（具体地，对于可变序列，流的分裂器是late-binding ）。如果在该操作期间修改了序列，则结果是未定义的。
    
    Specified by:
    
    codePoints在 CharSequence
    
    结果
    
    Unicode代码的IntStream指向此序列
    
    从以下版本开始：
    
    9

Class StringBuffer

构造方法摘要

方法摘要

声明方法的类 java.lang.Object

声明方法的接口 java.lang.CharSequence

构造方法详细信息

StringBuffer

StringBuffer

StringBuffer

StringBuffer

方法详细信息

compareTo

capacity

ensureCapacity

trimToSize

setLength

charAt

codePointAt

codePointBefore

codePointCount

offsetByCodePoints

getChars

setCharAt

append

append

append

append

append

append

append

append

append

append

appendCodePoint

append

append

append

delete

deleteCharAt

replace

substring

subSequence

substring

insert

insert

insert

insert

insert

insert

insert

insert

insert

insert

insert

insert

indexOf

indexOf

lastIndexOf

lastIndexOf

reverse

chars

codePoints