java.lang.Object

java.lang.StringBuffer

所有已实现的接口：: 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"。

通常，如果 sb 引用 StringBuffer 的实例，则 sb.append(x) 与 sb.insert(sb.length(), x) 具有相同的效果。

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

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

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

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

API 注意：

StringBuffer 实现 Comparable 但不覆盖 equals 。因此，StringBuffer 的自然排序与 equals 不一致。如果将 StringBuffer 对象用作 SortedMap 中的键或 SortedSet 中的元素，则应小心。有关详细信息，请参阅 Comparable 、SortedMap 或 SortedSet 。

自从：

1.0

参见：

构造方法总结

构造方法

构造方法

描述

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

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

length()

返回长度（字符数）。

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，其中包含当前包含在此序列中的字符子序列。

String

toString()

返回表示此序列中数据的字符串。

void

trimToSize()

尝试减少用于字符序列的存储。

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

在接口 java.lang.CharSequence 中声明的方法
chars, codePoints, isEmpty

构造方法详细信息
- 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参数的长度。
  
  参数：
  
  seq - 要复制的序列。
  
  自从：
  
  1.5
方法详情
- compareTo
  
  public int compareTo(StringBuffer another)
  
  按字典顺序比较两个 StringBuffer 实例。此方法遵循与 CharSequence.compare(this, another) 方法中定义的相同的词典比较规则。
  对于更细粒度、区域设置敏感的字符串比较，请参阅 Collator 。
  
  指定者：
  
  compareTo 在接口 Comparable<StringBuffer> 中
  
  实现注意事项：
  
  此方法在当前对象 this 上同步，但不在与 this StringBuffer 进行比较的 StringBuffer another 上同步。
  
  参数：
  
  another - 要与之比较的 StringBuffer
  
  返回：
  
  值 0 如果这个 StringBuffer 包含与参数 StringBuffer 相同的字符序列；如果此 StringBuffer 按字典顺序小于 StringBuffer 参数，则为负整数；或正整数，如果此 StringBuffer 按字典顺序大于 StringBuffer 参数。
  
  自从：
  
  11
- length
  
  public int length()
  
  返回长度（字符数）。
  
  指定者：
  
  length 在接口 CharSequence 中
  
  返回：
  
  此对象当前表示的字符序列的长度
- 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')，以便长度成为 newLength 参数。
  
  newLength 参数必须大于或等于 0。
  参数：
  
  newLength - 新长度
  
  抛出：
  
  IndexOutOfBoundsException - 如果 newLength 参数为负。
  
  参见：
  
  length()
- charAt
  
  public char charAt(int index)
  
  返回此序列中指定索引处的 char 值。第一个 char 值位于索引 0 ，下一个位于索引 1 ，依此类推，就像在数组索引中一样。
  索引参数必须大于或等于 0 且小于此序列的长度。
  
  如果索引指定的 char 值为代理人，则返回代理项值。
  指定者：
  
  charAt 在接口 CharSequence 中
  
  参数：
  
  index - 所需 char 值的索引。
  
  返回：
  
  指定索引处的 char 值。
  
  抛出：
  
  IndexOutOfBoundsException - 如果 index 为负或大于或等于 length()。
  
  参见：
  
  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() 。
  如果 (index - 1) 的 char 值在低代理范围内，(index - 2) 不为负，而 (index - 2) 的 char 值在高代理范围内，则返回代理对的补充代码点值。如果 index - 1 处的 char 值是未配对的低代理项或高代理项，则返回代理值。
  
  参数：
  
  index - 应该返回的代码点之后的索引
  
  返回：
  
  给定索引之前的 Unicode 代码点值。
  
  抛出：
  
  IndexOutOfBoundsException - 如果 index 参数小于 1 或大于此序列的长度。
  
  自从：
  
  1.5
- codePointCount
  
  public int codePointCount(int beginIndex, int endIndex)
  
  返回此序列的指定文本范围内的 Unicode 代码点数。文本范围从指定的 beginIndex 开始并扩展到索引 endIndex - 1 处的 char。因此，文本范围的长度（以 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 为负数并且 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 。此序列被更改为表示与旧字符序列相同的新字符序列，只是它在位置 index 处包含字符 ch。
  索引参数必须大于或等于 0 且小于此序列的长度。
  参数：
  
  index - 要修改的字符的索引。
  
  ch - 新角色。
  
  抛出：
  
  IndexOutOfBoundsException - 如果 index 为负或大于或等于 length()。
  
  参见：
  
  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新字符序列中的字符等于索引处的字符k在旧字符序列中，如果k小于n;否则，它等于索引处的字符千克在参数 str 中。
  
  参数：
  
  str - 一个字符串。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuffer append(StringBuffer sb)
  
  将指定的 StringBuffer 附加到此序列。
  StringBuffer 参数的字符按顺序附加到此 StringBuffer 的内容，将此 StringBuffer 的长度增加参数的长度。如果 sb 是 null，那么四个字符 "null" 将附加到这个 StringBuffer。
  
  让n是旧字符序列的长度，即在执行 append 方法之前包含在 StringBuffer 中的那个。然后索引处的字符k新字符序列中的字符等于索引处的字符k在旧字符序列中，如果k小于n;否则，它等于索引处的字符千克在参数 sb 中。
  
  此方法同步目标对象 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"。
  
  指定者：
  
  append 在接口 Appendable 中
  
  参数：
  
  s - 要追加的 CharSequence。
  
  返回：
  
  对此对象的引用。
  
  自从：
  
  1.5
- append
  
  public StringBuffer append(CharSequence s, int start, int end)
  
  将指定的 CharSequence 的子序列附加到此序列。
  参数 s 的字符，从索引 start 开始，按顺序附加到此序列的内容，直到（独占）索引 end 。该序列的长度增加了 end - start 的值。
  
  让n是执行 append 方法之前此字符序列的长度。然后索引处的字符k此字符序列中的字符等于索引处的字符k在这个序列中，如果k小于n;否则，它等于索引处的字符k+开始-n在参数 s 中。
  
  如果 s 是 null ，则此方法附加字符，就好像 s 参数是包含四个字符 "null" 的序列一样。
  
  指定者：
  
  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 数组参数的子数组的字符串表示形式附加到此序列。
  char 数组 str 的字符，从索引 offset 开始，按顺序附加到此序列的内容。该序列的长度增加了 len 的值。
  
  整体效果就像参数通过方法 String.valueOf(char[],int,int) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  str - 要追加的字符。
  
  offset - 要追加的第一个 char 的索引。
  
  len - 要附加的 char 的数量。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  IndexOutOfBoundsException - 如果 offset < 0 或 len < 0 或 offset+len > str.length
- append
  
  public StringBuffer append(boolean b)
  
  将 boolean 参数的字符串表示形式附加到序列中。
  整体效果就像参数通过方法 String.valueOf(boolean) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  b - 一个 boolean。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuffer append(char c)
  
  将 char 参数的字符串表示形式附加到此序列。
  参数附加到此序列的内容。该序列的长度增加1。
  
  整体效果就像参数通过方法 String.valueOf(char) 转换为字符串，然后该字符串中的字符被 appended 转换为该字符序列。
  
  指定者：
  
  append 在接口 Appendable 中
  
  参数：
  
  c - 一个 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 - 一个 long。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuffer append(float f)
  
  将 float 参数的字符串表示附加到此序列。
  整体效果就像参数通过方法 String.valueOf(float) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  f - 一个 float。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuffer append(double d)
  
  将 double 参数的字符串表示形式附加到此序列。
  整体效果就像参数通过方法 String.valueOf(double) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  d - 一个 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 。
  注意：如果给定索引处的字符是增补字符，则此方法不会删除整个字符。如果需要正确处理增补字符，请通过调用 Character.charCount(thisSequence.codePointAt(index)) 确定要删除的 char 的数量，其中 thisSequence 是此序列。
  
  参数：
  
  index - 要删除的 char 的索引
  
  返回：
  
  这个对象。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果 index 为负或大于或等于 length()。
  
  自从：
  
  1.2
- replace
  
  public StringBuffer replace(int start, int end, String str)
  
  用指定的 String 中的字符替换此序列的子字符串中的字符。子字符串从指定的 start 开始并扩展到索引 end - 1 处的字符，如果不存在这样的字符，则扩展到序列的末尾。首先删除子字符串中的字符，然后在 start 处插入指定的 String。（如有必要，将延长此序列以容纳指定的字符串。）
  
  参数：
  
  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 接口。
  指定者：
  
  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 - 一个 char 阵列。
  
  offset - 要插入的子数组中第一个 char 的索引。
  
  len - 要插入的子数组中 char 的数量。
  
  返回：
  
  这个对象
  
  抛出：
  
  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在旧字符序列中，如果k小于offset
  
  索引处的字符k-offset 在参数 str 中，如果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 的子序列插入此序列。
  start 和 end 指定的参数 s 的子序列按顺序插入此序列中指定的目标偏移量，向上移动最初位于该位置上方的任何字符。该序列的长度增加了end - start。
  
  索引处的字符k在这个序列中变得等于：
  
  索引处的字符k在这个序列中，如果k小于dstOffset
  
  索引处的字符k+start-dstOffset 在参数 s 中，如果k大于或等于 dstOffset 但小于 dstOffset+end-start
  
  索引处的字符k-(end-start) 在这个序列中，如果k大于或等于dstOffset+end-start
  
  dstOffset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  开始参数必须是非负的，并且不大于 end 。
  
  结束参数必须大于或等于 start 且小于或等于 s 的长度。
  
  如果 s 是 null，则此方法插入字符，就好像 s 参数是包含四个字符 "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 - 一个 boolean。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuffer insert(int offset, char c)
  
  将 char 参数的字符串表示形式插入此序列。
  整体效果就好像第二个参数通过方法 String.valueOf(char) 转换为字符串，然后该字符串中的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  c - 一个 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 - 一个 long。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuffer insert(int offset, float f)
  
  将 float 参数的字符串表示形式插入此序列。
  总体效果就好像第二个参数通过方法 String.valueOf(float) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  f - 一个 float。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuffer insert(int offset, double d)
  
  将 double 参数的字符串表示形式插入此序列。
  整体效果就好像第二个参数通过方法 String.valueOf(double) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  d - 一个 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
- toString
  
  public String toString()
  
  返回表示此序列中数据的字符串。分配并初始化一个新的 String 对象以包含该对象当前表示的字符序列。然后返回此 String。对该序列的后续更改不会影响 String 的内容。
  
  指定者：
  
  toString 在接口 CharSequence 中
  
  返回：
  
  此字符序列的字符串表示形式。
- chars
  
  public IntStream chars()
  
  返回一个 int 流，对该序列的 char 值进行零扩展。映射到代理码点的任何字符都将不经解释地通过。
  当终端流操作开始时，流绑定到这个序列（具体来说，对于可变序列，流的拆分器是 late-binding ）。如果在该操作期间修改了序列，则结果未定义。
  
  指定者：
  
  chars 在接口 CharSequence 中
  
  返回：
  
  来自此序列的 char 值的 IntStream
  
  自从：
  
  9
- codePoints
  
  public IntStream codePoints()
  
  返回此序列中的代码点值流。序列中遇到的任何代理对都被组合为 Character.toCodePoint 并将结果传递给流。任何其他代码单元，包括普通 BMP 字符、未配对的代理项和未定义的代码单元，都被零扩展为 int 值，然后传递给流。
  当终端流操作开始时，流绑定到这个序列（具体来说，对于可变序列，流的拆分器是 late-binding ）。如果在该操作期间修改了序列，则结果未定义。
  
  指定者：
  
  codePoints 在接口 CharSequence 中
  
  返回：
  
  来自此序列的 Unicode 代码点的 IntStream
  
  自从：
  
  9

类 StringBuffer

构造方法总结

方法总结

在类 java.lang.Object 中声明的方法

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

构造方法详细信息

StringBuffer

StringBuffer

StringBuffer

StringBuffer

方法详情

compareTo

length

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

toString

chars

codePoints