compareTo

public int compareTo(StringBuffer another)

按字典顺序比较两个 StringBuffer 实例。此方法遵循与 CharSequence.compare(this, another) 方法中定义的相同的词典比较规则。

对于更细粒度、区域设置敏感的字符串比较，请参阅 Collator 。

指定者：

compareTo 在接口 Comparable 中

实现注意事项：

此方法在当前对象 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 之前的子序列少于 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