java.lang.Object

java.lang.StringBuilder

所有已实现的接口：: Serializable , Appendable , CharSequence , Comparable<StringBuilder>

public final class StringBuilder extends Object implements Serializable , Comparable <StringBuilder >, CharSequence

可变的字符序列。此类提供与 StringBuffer 兼容的 API，但不保证同步。此类旨在用作 StringBuffer 在字符串缓冲区被单个线程使用的地方（通常情况下）的替代品。在可能的情况下，建议优先使用此类而不是 StringBuffer，因为在大多数实现中它会更快。

StringBuilder 上的主要操作是 append 和 insert 方法，它们被重载以接受任何类型的数据。每个有效地将给定的数据转换为字符串，然后将该字符串的字符附加或插入到字符串构建器中。 append 方法总是在构建器的末尾添加这些字符； insert 方法在指定点添加字符。

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

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

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

StringBuilder 的实例供多线程使用是不安全的。如果需要此类同步，则建议使用 StringBuffer 。

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

API 注意：

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

自从：

1.5

参见：

构造方法总结

构造方法

构造方法

描述

StringBuilder()

构造一个没有字符且初始容量为 16 个字符的字符串生成器。

StringBuilder(int capacity)

构造一个没有字符的字符串生成器，初始容量由 capacity 参数指定。

StringBuilder(CharSequence seq)

构造一个字符串生成器，其中包含与指定的 CharSequence 相同的字符。

StringBuilder(String str)

构造一个初始化为指定字符串内容的字符串生成器。
方法总结

修饰符和类型

方法

描述

StringBuilder

append(boolean b)

将 boolean 参数的字符串表示形式附加到序列中。

StringBuilder

append(char c)

将 char 参数的字符串表示形式附加到此序列。

StringBuilder

append(char[] str)

将 char 数组参数的字符串表示形式附加到此序列。

StringBuilder

append(char[] str, int offset, int len)

将 char 数组参数的子数组的字符串表示形式附加到此序列。

StringBuilder

append(double d)

将 double 参数的字符串表示形式附加到此序列。

StringBuilder

append(float f)

将 float 参数的字符串表示附加到此序列。

StringBuilder

append(int i)

将 int 参数的字符串表示形式附加到此序列。

StringBuilder

append(long lng)

将 long 参数的字符串表示形式附加到此序列。

StringBuilder

append(CharSequence s)

将指定的字符序列附加到此 Appendable 。

StringBuilder

append(CharSequence s, int start, int end)

将指定的 CharSequence 的子序列附加到此序列。

StringBuilder

append(Object obj)

附加 Object 参数的字符串表示形式。

StringBuilder

append(String str)

将指定的字符串附加到此字符序列。

StringBuilder

append(StringBuffer sb)

将指定的 StringBuffer 附加到此序列。

StringBuilder

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(StringBuilder another)

按字典顺序比较两个 StringBuilder 实例。

StringBuilder

delete(int start, int end)

删除此序列的子字符串中的字符。

StringBuilder

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)

从指定索引开始，返回第一次出现的指定子字符串在此字符串中的索引。

StringBuilder

insert(int offset, boolean b)

将 boolean 参数的字符串表示形式插入此序列。

StringBuilder

insert(int offset, char c)

将 char 参数的字符串表示形式插入此序列。

StringBuilder

insert(int offset, char[] str)

将 char 数组参数的字符串表示形式插入到此序列中。

StringBuilder

insert(int index, char[] str, int offset, int len)

将 str 数组参数的子数组的字符串表示形式插入到此序列中。

StringBuilder

insert(int offset, double d)

将 double 参数的字符串表示形式插入此序列。

StringBuilder

insert(int offset, float f)

将 float 参数的字符串表示形式插入此序列。

StringBuilder

insert(int offset, int i)

将第二个 int 参数的字符串表示形式插入此序列。

StringBuilder

insert(int offset, long l)

将 long 参数的字符串表示形式插入此序列。

StringBuilder

insert(int dstOffset, CharSequence s)

将指定的 CharSequence 插入此序列。

StringBuilder

insert(int dstOffset, CharSequence s, int start, int end)

将指定 CharSequence 的子序列插入此序列。

StringBuilder

insert(int offset, Object obj)

将 Object 参数的字符串表示形式插入此字符序列。

StringBuilder

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 代码点。

StringBuilder

replace(int start, int end, String str)

用指定的 String 中的字符替换此序列的子字符串中的字符。

StringBuilder

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 中声明的方法
charAt, chars, codePoints, isEmpty, length, subSequence

构造方法详细信息
- StringBuilder
  
  public StringBuilder()
  
  构造一个没有字符且初始容量为 16 个字符的字符串生成器。
- StringBuilder
  
  public StringBuilder(int capacity)
  
  构造一个没有字符的字符串生成器，初始容量由 capacity 参数指定。
  
  参数：
  
  capacity - 初始容量。
  
  抛出：
  
  NegativeArraySizeException - 如果 capacity 参数小于 0 。
- StringBuilder
  
  public StringBuilder(String str)
  
  构造一个初始化为指定字符串内容的字符串生成器。字符串生成器的初始容量是16加上字符串参数的长度。
  
  参数：
  
  str - 缓冲区的初始内容。
- StringBuilder
  
  public StringBuilder(CharSequence seq)
  
  构造一个字符串生成器，其中包含与指定的 CharSequence 相同的字符。字符串生成器的初始容量是 16 加上 CharSequence 参数的长度。
  
  参数：
  
  seq - 要复制的序列。
方法详情
- compareTo
  
  public int compareTo(StringBuilder another)
  
  按字典顺序比较两个 StringBuilder 实例。此方法遵循与 CharSequence.compare(this, another) 方法中定义的相同的词典比较规则。
  对于更细粒度、区域设置敏感的字符串比较，请参阅 Collator 。
  
  指定者：
  
  compareTo 在接口 Comparable<StringBuilder> 中
  
  参数：
  
  another - 要与之比较的 StringBuilder
  
  返回：
  
  值 0 如果这个 StringBuilder 包含与参数 StringBuilder 相同的字符序列；如果此 StringBuilder 按字典顺序小于 StringBuilder 参数，则为负整数；或正整数，如果此 StringBuilder 按字典顺序大于 StringBuilder 参数。
  
  自从：
  
  11
- append
  
  public StringBuilder append(Object obj)
  
  附加 Object 参数的字符串表示形式。
  整体效果就像参数通过方法 String.valueOf(Object) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  obj - 一个 Object。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(String str)
  
  将指定的字符串附加到此字符序列。
  String 参数的字符按顺序附加，按参数的长度增加此序列的长度。如果 str 是 null ，则附加四个字符 "null"。
  
  让n是执行 append 方法之前此字符序列的长度。然后索引处的字符k新字符序列中的字符等于索引处的字符k在旧字符序列中，如果k小于n;否则，它等于索引处的字符千克在参数 str 中。
  
  参数：
  
  str - 一个字符串。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(StringBuffer sb)
  
  将指定的 StringBuffer 附加到此序列。
  StringBuffer 参数的字符按顺序附加到此序列，按参数的长度增加此序列的长度。如果 sb 是 null ，则四个字符 "null" 将附加到此序列。
  
  让n是执行 append 方法之前此字符序列的长度。然后索引处的字符k新字符序列中的字符等于索引处的字符k在旧字符序列中，如果k小于n;否则，它等于索引处的字符千克在参数 sb 中。
  
  参数：
  
  sb - 要追加的 StringBuffer。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(CharSequence s)
  
  从接口 Appendable 复制的描述
  
  将指定的字符序列附加到此 Appendable 。
  根据实现字符序列 csq 的类，可能不会附加整个序列。例如，如果 csq 是一个 CharBuffer ，那么要附加的子序列由缓冲区的位置和限制定义。
  
  指定者：
  
  append 在接口 Appendable 中
  
  参数：
  
  s - 要追加的字符序列。如果 csq 是 null ，那么四个字符 "null" 被附加到这个 Appendable 中。
  
  返回：
  
  对此 Appendable 的引用
- append
  
  public StringBuilder 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()
- append
  
  public StringBuilder append(char[] str)
  
  将 char 数组参数的字符串表示形式附加到此序列。
  数组参数的字符按顺序附加到此序列的内容。该序列的长度随着参数的长度而增加。
  
  整体效果就像参数被方法 String.valueOf(char[]) 转换为字符串，然后该字符串的字符被 appended 转换为这个字符序列。
  
  参数：
  
  str - 要追加的字符。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder 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 StringBuilder append(boolean b)
  
  将 boolean 参数的字符串表示形式附加到序列中。
  整体效果就像参数通过方法 String.valueOf(boolean) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  b - 一个 boolean。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(char c)
  
  将 char 参数的字符串表示形式附加到此序列。
  参数附加到此序列的内容。该序列的长度增加1。
  
  整体效果就像参数通过方法 String.valueOf(char) 转换为字符串，然后该字符串中的字符被 appended 转换为该字符序列。
  
  指定者：
  
  append 在接口 Appendable 中
  
  参数：
  
  c - 一个 char。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(int i)
  
  将 int 参数的字符串表示形式附加到此序列。
  整体效果就像参数通过方法 String.valueOf(int) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  i - 一个 int。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(long lng)
  
  将 long 参数的字符串表示形式附加到此序列。
  整体效果就像参数被方法 String.valueOf(long) 转换为字符串，然后该字符串的字符被 appended 转换为这个字符序列。
  
  参数：
  
  lng - 一个 long。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(float f)
  
  将 float 参数的字符串表示附加到此序列。
  整体效果就像参数通过方法 String.valueOf(float) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  f - 一个 float。
  
  返回：
  
  对此对象的引用。
- append
  
  public StringBuilder append(double d)
  
  将 double 参数的字符串表示形式附加到此序列。
  整体效果就像参数通过方法 String.valueOf(double) 转换为字符串，然后该字符串的字符被 appended 转换为该字符序列。
  
  参数：
  
  d - 一个 double。
  
  返回：
  
  对此对象的引用。
- appendCodePoint
  
  public StringBuilder appendCodePoint(int codePoint)
  
  将 codePoint 参数的字符串表示形式附加到此序列。
  参数附加到此序列的内容。该序列的长度增加Character.charCount(codePoint) 。
  
  整体效果就像参数通过方法 Character.toChars(int) 转换为 char 数组，然后该数组中的字符被 appended 转换为该字符序列。
  
  参数：
  
  codePoint - 一个 Unicode 代码点
  
  返回：
  
  对此对象的引用。
  
  自从：
  
  1.5
- delete
  
  public StringBuilder delete(int start, int end)
  
  删除此序列的子字符串中的字符。子字符串从指定的 start 开始并扩展到索引 end - 1 处的字符，如果不存在这样的字符，则扩展到序列的末尾。如果 start 等于 end，则不进行任何更改。
  
  参数：
  
  start - 开始索引，包括在内。
  
  end - 结束索引，独占。
  
  返回：
  
  这个对象。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果 start 为负，大于 length() 或大于 end。
- deleteCharAt
  
  public StringBuilder deleteCharAt(int index)
  
  删除此序列中指定位置的 char。这个序列被缩短了一个 char 。
  注意：如果给定索引处的字符是增补字符，则此方法不会删除整个字符。如果需要正确处理增补字符，请通过调用 Character.charCount(thisSequence.codePointAt(index)) 确定要删除的 char 的数量，其中 thisSequence 是此序列。
  
  参数：
  
  index - 要删除的 char 的索引
  
  返回：
  
  这个对象。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果 index 为负或大于或等于 length()。
- replace
  
  public StringBuilder replace(int start, int end, String str)
  
  用指定的 String 中的字符替换此序列的子字符串中的字符。子字符串从指定的 start 开始并扩展到索引 end - 1 处的字符，如果不存在这样的字符，则扩展到序列的末尾。首先删除子字符串中的字符，然后在 start 处插入指定的 String。（如有必要，将延长此序列以容纳指定的字符串。）
  
  参数：
  
  start - 开始索引，包括在内。
  
  end - 结束索引，独占。
  
  str - 将替换以前内容的字符串。
  
  返回：
  
  这个对象。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果 start 为负，大于 length() 或大于 end。
- insert
  
  public StringBuilder 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 。
- insert
  
  public StringBuilder insert(int offset, Object obj)
  
  将 Object 参数的字符串表示形式插入此字符序列。
  整体效果就好像第二个参数通过方法 String.valueOf(Object) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  obj - 一个 Object。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder 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 StringBuilder insert(int offset, char[] str)
  
  将 char 数组参数的字符串表示形式插入到此序列中。
  数组参数的字符被插入到该序列内容中 offset 指示的位置。该序列的长度随着参数的长度而增加。
  
  整体效果就好像第二个参数通过方法 String.valueOf(char[]) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  str - 字符数组。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder insert(int dstOffset, CharSequence s)
  
  将指定的 CharSequence 插入此序列。
  CharSequence 参数的字符按顺序插入此序列中指定的偏移量，将原先位于该位置上方的任何字符向上移动，并将此序列的长度增加参数 s 的长度。
  
  此方法的结果与调用此对象的 insert (dstOffset, s, 0, s.length()) 方法的结果完全相同。
  
  如果 s 是 null ，则将四个字符 "null" 插入到此序列中。
  
  参数：
  
  dstOffset - 偏移量。
  
  s - 要插入的序列
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  IndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder 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()
- insert
  
  public StringBuilder insert(int offset, boolean b)
  
  将 boolean 参数的字符串表示形式插入此序列。
  总体效果就好像第二个参数通过方法 String.valueOf(boolean) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  b - 一个 boolean。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder insert(int offset, char c)
  
  将 char 参数的字符串表示形式插入此序列。
  整体效果就好像第二个参数通过方法 String.valueOf(char) 转换为字符串，然后该字符串中的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  c - 一个 char。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  IndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder insert(int offset, int i)
  
  将第二个 int 参数的字符串表示形式插入此序列。
  总体效果就好像第二个参数通过方法 String.valueOf(int) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  i - 一个 int。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder insert(int offset, long l)
  
  将 long 参数的字符串表示形式插入此序列。
  总体效果就好像第二个参数通过方法 String.valueOf(long) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  l - 一个 long。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder insert(int offset, float f)
  
  将 float 参数的字符串表示形式插入此序列。
  总体效果就好像第二个参数通过方法 String.valueOf(float) 转换为字符串，然后该字符串的字符在指示的偏移处 inserted 进入此字符序列。
  
  offset 参数必须大于或等于 0 且小于或等于此序列的 length。
  
  参数：
  
  offset - 偏移量。
  
  f - 一个 float。
  
  返回：
  
  对此对象的引用。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果偏移量无效。
- insert
  
  public StringBuilder 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。
- 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。
- lastIndexOf
  
  public int lastIndexOf(String str)
  返回最后一次出现的指定子字符串在此字符串中的索引。空字符串 "" 的最后一次出现被认为出现在索引值 this.length() 处。
  返回的索引是最大值 k，其中：
  
  this.toString().startsWith(str, k)
  如果 k 的值不存在，则返回 -1。
  参数：
  
  str - 要搜索的子字符串。
  
  返回：
  
  指定子字符串最后一次出现的索引，如果不存在则为 -1。
- 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。
- reverse
  
  public StringBuilder reverse()
  
  导致此字符序列被序列的反向替换。如果序列中包含任何代理对，则这些代理对将被视为反向操作的单个字符。因此，高-低代理项的顺序永远不会颠倒。让n是执行 reverse 方法之前此字符序列的字符长度（不是 char 值中的长度）。然后索引处的字符k新字符序列中的字符等于索引处的字符nk-1在旧字符序列中。
  请注意，反向操作可能会导致生成代理对，这些代理对在操作前是未配对的低代理和高代理。例如，反转“\uDC00\uD800”会生成“\uD800\uDC00”，这是一个有效的代理项对。
  
  返回：
  
  对此对象的引用。
- toString
  
  public String toString()
  
  返回表示此序列中数据的字符串。分配并初始化一个新的 String 对象以包含该对象当前表示的字符序列。然后返回此 String。对该序列的后续更改不会影响 String 的内容。
  
  指定者：
  
  toString 在接口 CharSequence 中
  
  返回：
  
  此字符序列的字符串表示形式。
- 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() 方法返回的值。
- setLength
  
  public void setLength(int newLength)
  
  设置字符序列的长度。该序列更改为一个新的字符序列，其长度由参数指定。对于每个非负索引k小于 newLength ，索引处的字符k新字符序列中的字符与索引处的字符相同k在旧序列中，如果k小于旧字符序列的长度；否则，它是空字符 '\u0000' 。换句话说，如果newLength参数小于当前长度，则将长度更改为指定长度。
  如果 newLength 参数大于或等于当前长度，则会附加足够的空字符 ('\u0000')，以便长度成为 newLength 参数。
  
  newLength 参数必须大于或等于 0。
  
  参数：
  
  newLength - 新长度
  
  抛出：
  
  IndexOutOfBoundsException - 如果 newLength 参数为负。
- charAt
  
  public char charAt(int index)
  
  返回此序列中指定索引处的 char 值。第一个 char 值位于索引 0 ，下一个位于索引 1 ，依此类推，就像在数组索引中一样。
  索引参数必须大于或等于 0 且小于此序列的长度。
  
  如果索引指定的 char 值为代理人，则返回代理项值。
  
  指定者：
  
  charAt 在接口 CharSequence 中
  
  参数：
  
  index - 所需 char 值的索引。
  
  返回：
  
  指定索引处的 char 值。
  
  抛出：
  
  IndexOutOfBoundsException - 如果 index 为负或大于或等于 length()。
- codePointAt
  
  public int codePointAt(int index)
  
  返回指定索引处的字符（Unicode 代码点）。索引指的是 char 值（Unicode 代码单元），范围从 0 到 CharSequence.length() - 1 。
  如果给定索引处指定的char值在高代理范围内，后续索引小于此序列的长度，且后续索引处的char值在低代理范围内，则补充代码点对应于这个代理对被返回。否则，返回给定索引处的 char 值。
  
  参数：
  
  index - char 值的索引
  
  返回：
  
  index 处字符的代码点值
  
  抛出：
  
  IndexOutOfBoundsException - 如果 index 参数为负数或不小于此序列的长度。
- 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 或大于此序列的长度。
- 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 。
- offsetByCodePoints
  
  public int offsetByCodePoints(int index, int codePointOffset)
  
  返回此序列中的索引，该索引从给定的 index 偏移 codePointOffset 代码点。 index 和 codePointOffset 给定的文本范围内的未配对代理各计为一个代码点。
  
  参数：
  
  index - 要偏移的索引
  
  codePointOffset - 代码点的偏移量
  
  返回：
  
  此序列中的索引
  
  抛出：
  
  IndexOutOfBoundsException - 如果 index 为负数或大于此序列的长度，或者如果 codePointOffset 为正数并且以 index 开头的子序列的代码点少于 codePointOffset 个，或者如果 codePointOffset 为负数并且 index 之前的子序列的绝对值小于codePointOffset 代码点。
- 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()。
- substring
  
  public String substring(int start)
  
  返回一个新的 String，其中包含当前包含在此字符序列中的字符子序列。子字符串从指定的索引开始并延伸到该序列的末尾。
  
  参数：
  
  start - 开始索引，包括在内。
  
  返回：
  
  新字符串。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果 start 小于零，或大于此对象的长度。
- 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
- substring
  
  public String substring(int start, int end)
  
  返回一个新的 String，其中包含当前包含在此序列中的字符子序列。子字符串从指定的 start 开始并扩展到索引 end - 1 处的字符。
  
  参数：
  
  start - 开始索引，包括在内。
  
  end - 结束索引，独占。
  
  返回：
  
  新字符串。
  
  抛出：
  
  StringIndexOutOfBoundsException - 如果 start 或 end 为负或大于 length()，或者 start 大于 end。
- 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

类 StringBuilder

构造方法总结

方法总结

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

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

构造方法详细信息

StringBuilder

StringBuilder

StringBuilder

StringBuilder

方法详情

compareTo

append

append

append

append

append

append

append

append

append

append

append

append

append

appendCodePoint

delete

deleteCharAt

replace

insert

insert

insert

insert

insert

insert

insert

insert

insert

insert

insert

insert

indexOf

indexOf

lastIndexOf

lastIndexOf

reverse

toString

length

capacity

ensureCapacity

trimToSize

setLength

charAt

codePointAt

codePointBefore

codePointCount

offsetByCodePoints

getChars

setCharAt

substring

subSequence

substring

chars

codePoints