StringBuffer

StringBuffer

StringBuffer ()

构造一个没有字符的字符串缓冲区，初始容量为16个字符。

StringBuffer

StringBuffer (int capacity)

构造一个没有字符的字符串缓冲区和指定的初始容量。

StringBuffer

StringBuffer (String str)

构造一个字符串缓冲区，初始化为指定字符串的内容。 字符串缓冲区的初始容量是16加上字符串参数的长度。

StringBuffer

StringBuffer (CharSequence seq)

构造一个字符串缓冲区，其中包含与指定的CharSequence相同的字符。 字符串缓冲的初始容量为16加上的长度CharSequence参数。

如果指定的 CharSequence的长度小于或等于零，则返回容量为 16的空缓冲区。

append

StringBuffer append (boolean b)

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

总体效果就好像参数被方法 valueOf(boolean)转换为字符串，并且该字符串的字符然后是该字符序列的 ERROR(appended/#append(String) appended) 。

append

StringBuffer append (long lng)

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

总体效果就好像通过方法 valueOf(long)将参数转换为字符串，然后该字符串的字符对该字符序列为 ERROR(appended/#append(String) appended) 。

append

StringBuffer append (char c)

在此序列中追加 char参数的字符串表示形式。

该参数被附加到该序列的内容。 这个序列的长度增加了1 。

整体效果就好像参数被方法 valueOf(char)转换为字符串，并且该字符串中的字符然后是该字符序列的 ERROR(appended/#append(String) appended) 。

append

StringBuffer append (Object obj)

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

总体效果就好像参数被方法 valueOf(Object)转换为字符串，并且该字符串的字符然后是该字符序列的 ERROR(appended/#append(String) appended) 。

append

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

将 char数组参数的子阵列的字符串表示追加到该序列。

所述的字符char阵列str ，开始于索引offset ，追加，为了以该序列的内容。 该序列的长度增加了len的值。

整体效果就好像参数通过方法 valueOf(char[], int, int)转换为字符串，然后该字符串的字符对此字符序列为 ERROR(appended/#append(String) appended) 。

append

StringBuffer append (double d)

将 double参数的字符串表示追加到该序列。

整体效果就好像参数被方法 valueOf(double)转换为字符串，并且该字符串的字符然后是 ERROR(appended/#append(String) appended)到该字符序列。

append

StringBuffer append (char[] str)

将 char数组参数的字符串表示追加到此序列中。

数组参数的字符按顺序附加到该序列的内容。 这个序列的长度增加了参数的长度。

总体效果就好像参数被方法 valueOf(char[])转换为字符串，然后该字符串的字符为 ERROR(appended/#append(String) appended) 。

append

StringBuffer append (String str)

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

String参数的字符按顺序附加在该参数的长度上，从而增加该序列的长度。 如果str是null ，则附加四个字符"null" 。

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

append

StringBuffer append (StringBuffer sb)

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

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

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

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

append

StringBuffer append (float f)

将 float参数的字符串表示追加到该序列。

总体效果就好像参数被方法 valueOf(float)转换为字符串，并且该字符串的字符然后是 ERROR(appended/#append(String) appended)这个字符序列。

append

StringBuffer append (int i)

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

整体效果就好像参数被方法 valueOf(int)转换为字符串，然后该字符串的字符为 ERROR(appended/#append(String) appended)即可。

append

StringBuffer append (CharSequence s, 
                int start, 
                int end)

将指定的 CharSequence序列 CharSequence到该序列。

从索引start开始的参数s字符按顺序附加到该序列的内容直到（排他）索引end 。 该序列的长度增加了end - start的值。

假设n是执行append方法之前的这个字符序列的长度。 然后在该字符序列索引k处的字符变为等于在索引k此序列中的字符，如果k小于n; 否则，它等于参数s中索引为k + start-n的s 。

如果 s是 null ，那么此方法会附加字符，就像s参数是包含四个字符 "null"的序列 "null" 。

append

StringBuffer append (CharSequence s)

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

CharSequence参数的字符按顺序附加，按顺序将参数的长度增加该序列的长度。

该方法的结果与调用this.append（s，0，s.length（））完全相同;

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

如果 s是 null ，则附加四个字符 "null" 。

appendCodePoint

StringBuffer appendCodePoint (int codePoint)

将 codePoint参数的字符串表示追加到此序列。

该参数被附加到该序列的内容。 这个序列的长度增加Character.charCount(codePoint) 。

总体效果就好像参数通过方法 toChars(int)转换为 char数组，然后该数组中的字符然后是该字符序列的 ERROR(appended/#append(char[]) appended) 。

capacity

int capacity ()

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

charAt

char charAt (int index)

以指定索引处的此顺序返回char值。 第一个char值为索引0 ，下一个索引为1 ，依此类推，如数组索引。

索引参数必须大于或等于 0 ，并且小于此序列的长度。

如果索引指定的 char值为 surrogate ，则返回代理值。

codePointAt

int codePointAt (int index)

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

如果给定索引处指定的char值处于高代理范围内，则以下索引小于此序列的长度，并且以下索引处的char值位于低代理范围内，则补充代码点对应于这个代理对被返回。 否则，返回给定索引处的char值。

codePointBefore

int codePointBefore (int index)

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

如果char在值(index - 1)处于低代理项范围， (index - 2)不为负，并且char在值(index - 2)处于高代理项范围，则返回代理对的补充代码点值。 如果char在值index - 1是未配对的低代理或一个高代理，则返回所述替代值。

codePointCount

int codePointCount (int beginIndex, 
                int endIndex)

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

delete

StringBuffer delete (int start, 
                int end)

删除此序列的子字符串中的字符。 子字符串从指定的start开始，并且延伸到索引为end - 1的字符或者如果不存在这样的字符则延伸到序列的末尾。 如果start等于end ，则不做任何更改。

deleteCharAt

StringBuffer deleteCharAt (int index)

按照此顺序移除指定位置的char 。 这个序列缩短了一个char 。

注意：如果给定索引处的字符是补充字符，则此方法不会删除整个字符。 如果需要的准确处理增补字符，确定数量char通过调用删除Character.charCount(thisSequence.codePointAt(index)) ，其中thisSequence是此序列。

ensureCapacity

void ensureCapacity (int minimumCapacity)

确保容量至少等于规定的最小值。 如果当前容量小于参数，则会为新的内部阵列分配更大的容量。 新的容量是以下数据中的较大者：

• The minimumCapacity argument.
• Twice the old capacity, plus 2.

getChars

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

将字符从此序列复制到目标字符数组dst 。 第一个要复制的字符位于索引号srcBegin ; 要复制的最后一个字符位于索引srcEnd-1 。 要复制的字符总数为srcEnd-srcBegin 。 字符被复制到dst的子dst从索引dstBegin开始并以索引结束：

 dstbegin + (srcEnd-srcBegin) - 1
 

indexOf

int indexOf (String str)

返回指定子字符串第一次出现的此字符串中的索引。 返回的整数是最小的值k ，使得：

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

indexOf

int indexOf (String str, 
                int fromIndex)

从指定索引处开始，返回指定子字符串第一次出现的此字符串中的索引。 返回的整数是最小值k ，其中：

     k >= Math.min(fromIndex, str.length()) &&
                   this.toString().startsWith(str, k)
 

insert

StringBuffer insert (int offset, 
                char[] str)

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

数组参数的字符被插入到该序列的内容中offset指示的位置。 这个序列的长度增加了参数的长度。

整体效果就好像第二个参数通过方法 valueOf(char[])转换为字符串，然后该字符串的字符在指定的偏移量处为 ERROR(inserted/#insert(int,String) inserted)转换为此字符序列。

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

insert

StringBuffer insert (int offset, 
                float f)

将 float参数的字符串表示插入到该序列中。

总体效果就好像第二个参数通过方法 valueOf(float)转换为字符串，然后该字符串的字符然后在指定的偏移量处插入该字符序列中的 ERROR(inserted/#insert(int,String) inserted) 。

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

insert

StringBuffer insert (int dstOffset, 
                CharSequence s)

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

参数 CharSequence的字符按顺序插入指定偏移量的该序列中，向上移动原始位置上方的任何字符，并将该序列的长度增加参数s的长度。

此方法的结果与调用此对象的 ERROR(insert/#insert(int,CharSequence,int,int) insert) （dstOffset，s，0，s.length（））方法 ERROR(insert/#insert(int,CharSequence,int,int) insert) 。

如果 s是 null ，则将四个字符 "null"插入此序列中。

insert

StringBuffer insert (int offset, 
                char c)

将 char参数的字符串表示插入到该序列中。

总体效果就好像第二个参数通过方法 valueOf(char)转换为字符串，然后该字符串中的字符以 ERROR(inserted/#insert(int,String) inserted)转换为指定偏移量的该字符序列。

参数 offset必须大于或等于 0 ，并小于或等于此序列的长度。

insert

StringBuffer insert (int offset, 
                long l)

将参数 long的字符串表示插入到该序列中。

整体效果就好像第二个参数通过方法 valueOf(long)转换为字符串，然后该字符串的字符然后在指定的偏移量处插入此字符序列中的 ERROR(inserted/#insert(int,String) inserted) 。

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

insert

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

将str数组参数的子数组的字符串表示插入到此序列中。 该子阵列开始于指定的offset并延伸至len char s。 子index字符在index指示的位置插入到该序列中。 这个序列的长度增加len char 。

insert

StringBuffer insert (int offset, 
                int i)

将第二 int参数 int的字符串表示插入到该序列中。

整体效果就好像第二个参数通过方法 valueOf(int)转换为字符串，并且该字符串的字符然后在指定的偏移量处插入此字符序列中的 ERROR(inserted/#insert(int,String) inserted) 。

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

insert

StringBuffer insert (int offset, 
                String str)

将字符串插入到此字符序列中。

参数String的字符按顺序插入指定偏移量的该序列中，向上移动位于该位置上方的任何字符，并将该序列的长度增加参数的长度。 如果str是null ，则将四个字符"null"插入此序列中。

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

• the character at index k in the old character sequence, if k is less than offset
• the character at index k-offset in the argument str, if k is not less than offset but is less than offset+str.length()
• the character at index k-str.length() in the old character sequence, if k is not less than offset+str.length()

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

insert

StringBuffer insert (int offset, 
                double d)

将 double参数的字符串表示插入到该序列中。

总体效果就好像第二个参数通过方法 valueOf(double)转换为字符串，然后该字符串的字符然后在指定的偏移量处插入此字符序列中的 ERROR(inserted/#insert(int,String) inserted) 。

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

insert

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

将指定的 CharSequence序列插入到该序列中。

参数的子序列s通过指定start和end被插入，以便成在指定的目的地偏移该序列中，该位置上述最初向上运动的任何字符。 这个序列的长度增加了end - start 。

在这个序列中的索引 k处的字符变成等于：

• the character at index k in this sequence, if k is less than dstOffset
• the character at index k+start-dstOffset in the argument s, if k is greater than or equal to dstOffset but is less than dstOffset+end-start
• the character at index k-(end-start) in this sequence, if k is greater than or equal to dstOffset+end-start

参数 dstOffset必须大于或等于 0 ，并且小于或等于此序列的长度。

开始参数必须是非负的，不能大于 end 。

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

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

insert

StringBuffer insert (int offset, 
                Object obj)

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

整体效果就好像第二个参数通过方法 valueOf(Object)转换为字符串，然后该字符串的字符然后在指定的偏移量处插入此字符序列中的 ERROR(inserted/#insert(int,String) inserted) 。

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

insert

StringBuffer insert (int offset, 
                boolean b)

将 boolean参数的字符串表示插入到该序列中。

整体效果就好像第二个参数通过方法 valueOf(boolean)转换为字符串，然后该字符串的字符以 ERROR(inserted/#insert(int,String) inserted)转换为指定偏移量处的该字符序列。

参数 offset必须大于或等于 0 ，并且小于或等于此序列的长度。

lastIndexOf

int lastIndexOf (String str, 
                int fromIndex)

返回指定子字符串最后一次出现的此字符串中的索引。 返回的整数是最大值k ，使得：

     k <= Math.min(fromIndex, str.length()) &&
                   this.toString().startsWith(str, k)
 

lastIndexOf

int lastIndexOf (String str)

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

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

length

int length ()

返回长度（字符数）。

offsetByCodePoints

int offsetByCodePoints (int index, 
                int codePointOffset)

返回此序列，其从给定的偏移处的索引index通过codePointOffset代码点。 由index和codePointOffset给出的文本范围内的未配对代理每个计为一个代码点。

replace

StringBuffer replace (int start, 
                int end, 
                String str)

用指定的String的字符替换此序列的子字符串中的字符。 子字符串从指定的start开始，并延伸到索引为end - 1的字符，或者如果不存在这样的字符，则延伸到序列的末尾。 首先删除子字符串中的字符，然后在String处插入指定的start 。 （如果需要，此序列将被延长以适应指定的字符串。）

reverse

StringBuffer reverse ()

导致该字符序列被序列的反向替换。 如果序列中包含任何代理对，则这些代码将被视为反向操作的单个字符。 因此，高低代理人的顺序永远不会颠倒过来。 假设n是在执行reverse方法之前，此字符序列的字符长度（不是char值中的长度）。 然后，新字符序列中索引k处的字符等于旧字符序列中索引nk-1处的字符。

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

setCharAt

void setCharAt (int index, 
                char ch)

指定索引处的字符设置为ch 。 该序列被改变以表示一个新的字符序列，其是相同的原字符序列，不同之处在于它包含字符ch在位置index 。

索引参数必须大于或等于 0 ，并且小于此序列的长度。

setLength

void setLength (int newLength)

设置字符序列的长度。 序列更改为新的字符序列，其长度由参数指定。 对于小于每非负索引k newLength ，在新的字符序列的索引k处的字符是相同的在旧序列索引k如果k小于原字符序列的长度的字符; 否则，它是空字符'\u0000' 。 换句话说，如果参数newLength小于当前长度，则长度将更改为指定的长度。

如果参数 newLength大于或等于当前长度，则会附加足够的空字符（ '\u0000' ），以使长度变为 newLength参数。

参数 newLength必须大于或等于 0 。

subSequence

CharSequence subSequence (int start, 
                int end)

返回一个新的字符序列，该序列是该序列的子序列。

这种形式的方法的调用

 sb.subSequence(begin, end)

 sb.substring(begin, end)

substring

String substring (int start, 
                int end)

返回一个新的String ，其中包含当前包含在此序列中的字符的子序列。 子字符串从指定的start开始并延伸到索引号为end - 1的字符。

substring

String substring (int start)

返回一个新的String ，其中包含当前包含在此字符序列中的字符的子序列。 子字符串从指定的索引处开始并延伸到该序列的末尾。

toString

String toString ()

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

trimToSize

void trimToSize ()

尝试减少用于字符序列的存储空间。 如果缓冲区比保留当前字符序列所需的缓冲区大，那么可能会调整缓冲区的大小以提高空间利用率。 调用此方法可能会影响随后调用capacity（）方法返回的值，但不是必需的。