java.lang.Object
- java.lang.StringBuilder

All Implemented Interfaces:

Serializable ， Appendable ， CharSequence
```
public final class StringBuilder
extends Object
implements Serializable, CharSequence
```
一个可变的字符序列。该类提供了一个与StringBuffer兼容的API，但不能保证同步。该类被设计为在字符串缓冲区被单个线程使用的地方（作为一般情况）用作StringBuffer替代替代。在可能的情况下，建议使用这个类别优先于StringBuffer因为它在大多数实施中将更快。
一个StringBuilder的主要操作是append和insert方法，它们是重载的，以便接受任何类型的数据。每个都有效地将给定的数据转换为字符串，然后将该字符串的字符附加或插入字符串构建器。 append方法总是在构建器的末尾添加这些字符; insert方法将字符添加到指定点。

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

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

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

StringBuilder实例不能安全使用多线程。如果需要同步，那么建议使用StringBuffer 。

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

从以下版本开始：

1.5

另请参见：

StringBuffer ， String ， Serialized Form

构造方法摘要

构造方法
Constructor	描述
`StringBuilder()`	构造一个没有字符的字符串构建器，初始容量为16个字符。
`StringBuilder(int capacity)`	构造一个没有字符的字符串构建器，以及由 `capacity`参数指定的初始容量。
`StringBuilder(CharSequence seq)`	构造一个字符串构建器，其中包含与指定的 `CharSequence`相同的字符。
`StringBuilder(String str)`	构造一个初始化为指定字符串内容的字符串构建器。

方法摘要

所有方法接口方法具体的方法
Modifier and Type	方法	描述
`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()`	从此序列返回码流值。
`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()`	尝试减少用于字符序列的存储。

Methods inherited from interface java.lang.CharSequence
charAt, chars, codePoints, length, subSequence

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- 构造方法详细信息
  - 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 - 要复制的顺序。
- 方法详细信息
  - append
```
public StringBuilder append(Object obj)
```
    追加Object参数的字符串表示形式。
    整体效果就好像通过方法String.valueOf(Object)将参数转换为字符串，并且该字符串的字符然后是该字符序列的appended 。
    
    参数
    
    obj - 一个 Object 。
    
    结果
    
    对这个对象的引用。
  - append
```
public StringBuilder append(String str)
```
    将指定的字符串附加到此字符序列。
    附加String参数的字符，以便String参数的长度增加此序列的长度。如果str为null ，则附加四个字符"null" 。
    
    在执行append方法之前，让n为该字符序列的长度。那么如果k小于n ，则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则，它等于参数str中的索引kn处的字符。
    
    参数
    
    str - 一个字符串。
    
    结果
    
    对这个对象的引用。
  - append
```
public StringBuilder append(StringBuffer sb)
```
    追加指定的StringBuffer到这个序列。
    按照序列的顺序追加StringBuffer参数的字符，将该序列的长度增加到参数的长度。如果sb为null ，则该序列附加四个字符"null" 。
    
    在执行append方法之前，让n为该字符序列的长度。那么如果k小于n ，则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则，它等于参数sb中的索引kn处的字符。
    
    参数
    
    sb - 附加的 StringBuffer 。
    
    结果
    
    对这个对象的引用。
  - append
```
public StringBuilder append(CharSequence s)
```
    描述从接口Appendable复制
    
    将指定的字符序列追加到此Appendable 。
    根据哪个类实现字符序列csq ，整个序列可能不被附加。例如，如果csq是一个CharBuffer，则附加的子序列由缓冲区的位置和限制来定义。
    
    Specified by:
    
    append在接口 Appendable
    
    参数
    
    s - 要追加的字符序列。如果csq为null ，则该"null"可附加四个字符"null" 。
    
    结果
    
    参考这个 Appendable
  - append
```
public StringBuilder append(CharSequence s,
                            int start,
                            int end)
```
    追加指定的序列CharSequence序列。
    从索引start开始的参数s字符按顺序附加到该序列的内容，直到（排他）索引end 。该序列的长度增加了end - start的值。
    
    在执行append方法之前，让n为该字符序列的长度。那么如果k小于n ，则该字符序列中的索引k处的字符变得等于该序列中索引k处的字符; 否则，它等于参数s中的索引k + start-n处的s 。
    
    如果s为null ，则该方法将字符附加为s参数是包含四个字符"null"的序列。
    
    Specified by:
    
    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数组参数的子阵列的字符串表示附加到此序列。
    从索引offset开始的char阵列str字符按顺序附加到该序列的内容。该序列的长度增加值为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 - a boolean 。
    
    结果
    
    对这个对象的引用。
  - append
```
public StringBuilder append(char c)
```
    将char参数的字符串表示附加到此序列。
    该参数附加到此序列的内容。该序列的长度增加1 。
    
    整体效果就好像通过方法String.valueOf(char)将参数转换为字符串，该字符串中的字符然后是这个字符序列的appended 。
    
    Specified by:
    
    append在接口 Appendable
    
    参数
    
    c - a 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 - a long 。
    
    结果
    
    对这个对象的引用。
  - append
```
public StringBuilder append(float f)
```
    将float参数的字符串表示法附加到此序列。
    整体效果就好像通过方法String.valueOf(float)将参数转换为字符串，并且该字符串的字符然后是这个字符序列的appended 。
    
    参数
    
    f - a float 。
    
    结果
    
    对这个对象的引用。
  - append
```
public StringBuilder append(double d)
```
    将double参数的字符串表示追加到此序列。
    整体效果就好像通过方法String.valueOf(double)将参数转换为字符串，并且该字符串的字符然后是该字符序列的appended 。
    
    参数
    
    d - a 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的Character.charCount(thisSequence.codePointAt(index)) ，其中thisSequence为该序列。
    
    参数
    
    index - 索引 char删除
    
    结果
    
    这个对象。
    
    异常
    
    StringIndexOutOfBoundsException - 如果 index为负数或大于或等于 length() 。
  - replace
```
public StringBuilder replace(int start,
                             int end,
                             String str)
```
    将此序列的子字符串中的字符替换为指定的String字符。子字符串从指定的start开始，并扩展到索引号为end - 1的字符，如果不存在这样的字符，则扩展到序列的末尾。首先删除子字符串中的字符，然后在String插入指定的start 。（如果需要，此序列将被延长以容纳指定的字符串。）
    
    参数
    
    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 - A 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 - a Object 。
    
    结果
    
    对这个对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuilder insert(int offset,
                            String str)
```
    将字符串插入到此字符序列中。
    String参数的字符按顺序插入到指定偏移量的该序列中，向上移动原始位于该位置的任何字符，并将该序列的长度增加到参数的长度。如果str为null ，则四个字符"null"被插入到该序列中。
    
    新字符序列中索引k处的字符等于：
    
    如果k小于offset ，则旧字符序列中的索引k处的字符
    
    在索引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序列。
    参数的子序列s通过指定start和end被插入，以便成在指定的目的地偏移该序列中，该位置上述最初向上运动的任何字符。该序列的长度增加end - start 。
    
    该序列中索引k处的字符等于：
    
    如果k小于dstOffset ，则该序列中索引k处的字符
    
    参数s中索引k +start-dstOffset处的字符，如果k大于或等于dstOffset但小于dstOffset+end-start
    
    在该序列中的索引k -(end-start)处的字符，如果k大于或等于dstOffset+end-start
    
    dstOffset参数必须大于或等于0 ，小于或等于该序列的length 。
    
    起始参数必须是非负数，不得大于end 。
    
    结束参数必须大于或等于start ，小于或等于s的长度。
    
    如果s是null ，则该方法插入字符，就像s参数是包含四个字符"null"的序列"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 - a boolean 。
    
    结果
    
    对这个对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移量无效。
  - insert
```
public StringBuilder insert(int offset,
                            char c)
```
    将char参数的字符串表示插入到此序列中。
    总体效果就好像第二个参数通过方法String.valueOf(char)转换为一个字符串，并且该字符串中的字符然后是inserted到指定的偏移量的这个字符序列。
    
    offset参数必须大于或等于0 ，并小于或等于此序列的length 。
    
    参数
    
    offset - 偏移。
    
    c - a char 。
    
    结果
    
    对这个对象的引用。
    
    异常
    
    IndexOutOfBoundsException - 如果偏移量无效。
  - insert
```
public StringBuilder insert(int offset,
                            int i)
```
    将第二个int参数的字符串表示插入到此序列中。
    整体效果就好像通过方法String.valueOf(int)将第二个参数转换为字符串，并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。
    
    offset参数必须大于或等于0 ，小于或等于此序列的length 。
    
    参数
    
    offset - 偏移量。
    
    i - a int 。
    
    结果
    
    对这个对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuilder insert(int offset,
                            long l)
```
    在此序列中插入long参数的字符串表示形式。
    总体效果就好像第二个参数通过方法String.valueOf(long)转换为一个字符串，并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。
    
    offset参数必须大于或等于0 ，小于或等于此序列的length 。
    
    参数
    
    offset - 偏移量。
    
    l - a long 。
    
    结果
    
    对这个对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移量无效。
  - insert
```
public StringBuilder insert(int offset,
                            float f)
```
    将float参数的字符串表示插入到此序列中。
    总体效果就好像第二个参数通过方法String.valueOf(float)转换为一个字符串，并且该字符串的字符然后是inserted到指定的偏移量的这个字符序列。
    
    offset参数必须大于或等于0 ，并且小于或等于此序列的length 。
    
    参数
    
    offset - 偏移。
    
    f - a float 。
    
    结果
    
    对这个对象的引用。
    
    异常
    
    StringIndexOutOfBoundsException - 如果偏移无效。
  - insert
```
public StringBuilder 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 。
  - 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()
```
    导致该字符序列被序列的相反代替。如果序列中包含任何替代对，则将它们视为单个字符进行反向操作。因此，高低替代品的顺序从未被扭转过。在执行reverse方法之前，让n为该字符序列的字符长度（不是char的长度）。那么新字符序列中的索引k处的字符等于旧字符序列中的索引nk-1处的字符。
    请注意，相反的操作可能会导致在手术之前产生不配对的低代谢和高代谢的替代对。例如，反转“\ uDC00 \ uD800”会生成“\ uD800 \ uDC00”，它是一个有效的代理对。
    
    结果
    
    对这个对象的引用。
  - toString
```
public String toString()
```
    返回表示此顺序中的数据的字符串。新的String对象被分配和初始化以包含此对象当前表示的字符序列。然后返回String 。对此序列的后续更改不影响String的内容。
    
    Specified by:
    
    toString在接口 CharSequence
    
    结果
    
    这个字符序列的字符串表示。
  - length
```
public int length()
```
    返回长度（字符数）。
    
    Specified by:
    
    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值为surrogate ，则返回替代值。
    
    Specified by:
    
    charAt在接口 CharSequence
    
    参数
    
    index - index的指数 char 。
    
    结果
    
    指定的指数为 char 。
    
    异常
    
    IndexOutOfBoundsException - 如果 index为负数或大于或等于 length() 。
  - codePointAt
```
public int codePointAt(int index)
```
    返回指定索引处的字符（Unicode代码点）。索引指的是char值（Unicode代码单位），范围从0到length() - 1 。
    如果在给定索引处指定的char值处于高代理范围内，则以下索引小于该序列的长度，并且以下索引处的char值处于低代理范围内，则补码代码点相应的这个代理对被退回。否则，返回给定索引处的char值。
    
    参数
    
    index - 索引为 char值
    
    结果
    
    字符的代码点值在 index
    
    异常
    
    IndexOutOfBoundsException - 如果 index参数为负数或不小于此序列的长度。
  - codePointBefore
```
public int codePointBefore(int index)
```
    返回指定索引之前的字符（Unicode代码点）。索引指的是char值（Unicode代码单位），范围从1到length() 。
    如果char的(index - 1)处于低代理区间，则(index - 2)不为负，而char为(index - 2) ，处于高替代范围，则返回替代对的补码代码值。如果char在值index - 1是未配对的低代理或一个高代理，则返回所述替代值。
    
    参数
    
    index - 应该返回的代码点之后的索引
    
    结果
    
    Unicode代码点值在给定索引之前。
    
    异常
    
    IndexOutOfBoundsException - 如果 index参数小于1或大于此序列的长度。
  - codePointCount
```
public int codePointCount(int beginIndex,
                          int endIndex)
```
    返回此序列指定文本范围内的Unicode代码点数。文本范围始于指定beginIndex并延伸到char在索引endIndex - 1 。因此，文本范围的长度（ char秒）为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开始的子 index具有少于 codePointOffset码点，或者如果 codePointOffset为负，并且 index之前的子 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 。该序列被改变以表示一个新的字符序列，其是相同的原字符序列，不同之处在于它包含字符ch在位置index 。
    索引参数必须大于或等于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接口。
    Specified by:
    
    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的数据流， 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 StringBuilder

构造方法摘要

方法摘要

Methods inherited from interface java.lang.CharSequence

Methods inherited from class java.lang.Object

构造方法详细信息

StringBuilder

StringBuilder

StringBuilder

StringBuilder

方法详细信息

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