compact1, compact2, compact3

java.lang

Class StringBuffer

java.lang.Object

java.lang.StringBuffer

All Implemented Interfaces:

Serializable ， Appendable ， CharSequence

public final class StringBuffer
extends Object
implements Serializable, CharSequence

线程安全，可变的字符序列。 字符串缓冲区就像一个String ，但可以修改。 在任何时间点，它包含一些特定的字符序列，但可以通过某些方法调用来更改序列的长度和内容。

字符串缓冲区可以安全地被多个线程使用。 这些方法在必要时进行同步，以便任何特定实例上的所有操作都按照与所涉及的各个线程所执行的方法调用顺序一致的顺序发生。

StringBuffer的主要StringBuffer是append和insert方法，它们被重载以便接受任何类型的数据。 每个都有效地将给定的数据转换为字符串，然后将该字符串的字符附加或插入到字符串缓冲区。 append方法总是在缓冲区的末尾添加这些字符; insert方法将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应该使用StringBuilder类，因为它支持所有相同的操作，但它更快，因为它不执行同步。

从以下版本开始：

JDK1.0

另请参见：

StringBuilder ， String ， Serialized Form

构造方法摘要

构造方法

Constructor and Description
StringBuffer() 构造一个没有字符的字符串缓冲区，初始容量为16个字符。
StringBuffer(CharSequence seq) 构造一个包含与指定的相同字符的字符串缓冲区 CharSequence 。
StringBuffer(int capacity) 构造一个没有字符的字符串缓冲区和指定的初始容量。
StringBuffer(String str) 构造一个初始化为指定字符串内容的字符串缓冲区。

方法摘要

Modifier and Type	Method and Description
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(CharSequence s) 追加指定的 CharSequence到这个序列。
StringBuffer	append(CharSequence s, int start, int end) 追加指定的序列 CharSequence到这个序列。
StringBuffer	append(double d) 将 double参数的字符串表示附加到此序列。
StringBuffer	append(float f) 将 float参数的字符串表示附加到此序列。
StringBuffer	append(int i) 将 int参数的字符串表示附加到此序列。
StringBuffer	append(long lng) 将 long参数的字符串表示附加到此序列。
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在指定索引在这个序列值。
int	codePointAt(int index) 返回指定索引处的字符（Unicode代码点）。
int	codePointBefore(int index) 返回指定索引之前的字符（Unicode代码点）。
int	codePointCount(int beginIndex, int endIndex) 返回此序列指定文本范围内的Unicode代码点数。
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 dstOffset, CharSequence s) 将指定的 CharSequence这个序列。
StringBuffer	insert(int dstOffset, CharSequence s, int start, int end) 将指定的子序列 CharSequence这个序列。
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 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中的字符替换此序列的子字符串中的 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() 尝试减少用于字符序列的存储。

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence

chars, codePoints

构造方法详细信息

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

方法详细信息

length

public int length()

返回长度（字符数）。

Specified by:

length在界面 CharSequence

结果

当前由此对象表示的字符序列的长度

capacity

public int capacity()

返回当前容量。 容量是新插入字符可用的存储量，超过此值将进行分配。

结果

当前的容量

ensureCapacity

public void ensureCapacity(int minimumCapacity)

确保容量至少等于规定的最小值。 如果当前容量小于参数，则会分配一个新的内部数组，容量更大。 新产能较大：

• minimumCapacity论证。
• 两倍的旧容量，加上2 。

如果minimumCapacity参数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由索引指定的值是surrogate ，则返回所述替代值。

Specified by:

charAt在界面 CharSequence

参数

index - 所需指数 char值。

结果

char在指定的索引值。

异常

IndexOutOfBoundsException - 如果 index为负数或大于或等于 length() 。

另请参见：

length()

codePointAt

public int codePointAt(int index)

返回指定索引处的字符（Unicode代码点）。 该索引指的是char值（Unicode代码单元），范围从0到length() - 1 。

如果char给定索引处指定的值处于高代理项范围，下列指数小于该序列的长度，和char以下索引处的值是在低代理项范围，则补充代码点相应的这个代理对被退回。 否则，返回给定索引处的char值。

参数

index - 指数为 char值

结果

字符的代码点值在 index

从以下版本开始：

1.5

codePointBefore

public int codePointBefore(int index)

返回指定索引之前的字符（Unicode代码点）。 该索引指的是char值（Unicode代码单位），范围从1到length() 。

char中(index - 1)为低代数范围时， (index - 2)为负， char为(index - 2)为高代数范围，则返回替代对的补码代码值。 如果char值为index - 1是不配对的低代理或高替代值，则返回替代值。

参数

index - 应该返回的代码点 index的索引

结果

Unicode代码点值在给定索引之前。

从以下版本开始：

1.5

codePointCount

public int codePointCount(int beginIndex,
                          int endIndex)

返回此序列指定文本范围内的Unicode代码点数。 文本范围始于指定beginIndex并延伸到char在索引endIndex - 1 。 因此，文本范围的长度（ char ）为endIndex-beginIndex 。 该序列中的未配对代理计数为每个代码点。

参数

beginIndex - 索引到第一个 char的文本范围。

endIndex - 最后一个 char之后的索引。

结果

指定文本范围内的Unicode代码点数

从以下版本开始：

1.5

offsetByCodePoints

public int offsetByCodePoints(int index,
                              int codePointOffset)

返回此序列中与index （ codePointOffset代码点偏移的索引。 index和codePointOffset给出的文本范围内的非配对替代品每个作为一个代码点。

参数

index - 要偏移的索引

codePointOffset - 代码点的偏移量

结果

该序列中的索引

从以下版本开始：

1.5

getChars

public void getChars(int srcBegin,
                     int srcEnd,
                     char[] dst,
                     int dstBegin)

字符从该序列复制到目标字符数组dst 。 要复制的第一个字符是索引srcBegin ; 要复制的最后一个字符在索引srcEnd-1 。 要复制的srcEnd-srcBegin总数为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() 。

另请参见：

length()

append

public StringBuffer append(Object obj)

追加Object参数的字符串表示。

总的效果是完全一样如果参数是由该方法转换成一个字符串String.valueOf(Object) ，而字符串的字符然后appended到此字符序列。

参数

obj - 一个 Object 。

结果

对这个对象的引用。

append

public StringBuffer append(String str)

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

附加String参数的字符，以便String参数的长度增加此序列的长度。 如果str是null ，则附加四个字符"null" 。

令n是在执行append方法之前这个字符序列的长度。 那么如果k小于n ，则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则，它等于参数str中的索引kn处的str 。

参数

str - 一个字符串。

结果

对这个对象的引用。

append

public StringBuffer append(StringBuffer sb)

将指定StringBuffer这个序列。

StringBuffer参数的StringBuffer按顺序附加到此StringBuffer的内容中，根据参数的长度增加此StringBuffer的长度。 如果sb是null ，那么四个字符"null"附在这个StringBuffer 。

让n是旧字符序列的长度， StringBuffer之前包含在append方法之前。 那么如果k小于n ，则新字符序列中索引k处的字符等于旧字符序列中索引k处的字符; 否则，它等于参数sb中的索引kn处的sb 。

此方法在this上同步目标对象，但不会在源上同步（ sb ）。

参数

sb - 附加的 StringBuffer 。

结果

对这个对象的引用。

从以下版本开始：

1.4

append

public StringBuffer append(CharSequence s)

追加指定的CharSequence到这个序列。

附加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的数量。

结果

对这个对象的引用。

异常

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中的字符替换此序列的子字符串中的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秒。 子阵列的字符在index的位置被插入到该序列中。 该序列的长度增加len char s。

参数

index - 插入子阵列的位置。

str - A 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参数的String按顺序插入到指定偏移量的该序列中，向上移动原始位于该位置的任何字符，并将该序列的长度增加到参数的长度。 如果str是null ，则四个字符"null"被插入到该序列中。

新字符序列中索引k处的字符等于：

• 老字符序列中的索引k处的字符，如果k小于offset
• 参数str中索引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参数的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小于dstOffset ，则该序列中索引k处的dstOffset
• 参数s中索引k +start-dstOffset的s ，如果k大于或等于dstOffset但小于dstOffset+end-start
• 如果k大于或等于dstOffset+end-start ，则该顺序中的索引k -(end-start)处的dstOffset+end-start

dstOffset参数必须大于或等于0 ，小于或等于此序列的length 。

起始参数必须是非负数，不得大于end 。

结束参数必须大于或等于start ，小于或等于s的长度。

如果s是null ，则该方法插入字符，就像s参数是包含四个字符"null"的序列"null" 。

参数

dstOffset - 此序列中的偏移量。

s - 要插入的序列。

start - 插入 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 - an 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, <i>k</i>)  

是true 。

参数

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.4

lastIndexOf

public int lastIndexOf(String str)

返回指定子字符串最右边出现的字符串内的索引。 最右边的空字符串“”被认为发生在索引值this.length() 。 返回的索引是最大的值k

   this.toString().startsWith(str, k)  

是真的。

参数

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.4

reverse

public StringBuffer reverse()

导致该字符序列被序列的相反代替。 如果序列中包含任何替代对，则将它们视为单个字符进行反向操作。 因此，高低替代品的顺序从未被扭转过。 在执行reverse方法之前，让n为该字符序列的字符长度（不是char值的长度）。 那么新字符序列中的索引k处的字符等于旧字符序列中的索引nk-1处的字符。

请注意，相反的操作可能会导致在手术之前产生不配对的低代理和高代谢的替代对。 例如，反转“\ uDC00 \ uD800”会生成“\ uD800 \ uDC00”，它是一个有效的代理对。

结果

对这个对象的引用。

从以下版本开始：

JDK1.0.2

toString

public String toString()

返回表示此顺序中的数据的字符串。 新的String对象被分配并初始化为包含此对象当前表示的字符序列。 然后返回String 。 对此序列的后续更改不影响String的内容。

Specified by:

toString在界面 CharSequence

结果

这个字符序列的字符串表示。