public final class StringBuffer extends Object implements Appendable, CharSequence, Serializable
String, but can
be modified. At any point in time it contains some particular sequence of characters, but the
length and content of the sequence can be changed through certain method calls.
String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all the operations on any particular instance behave as if they occur in some serial order that is consistent with the order of the method calls made by each of the individual threads involved.
The principal operations on a StringBuffer are the append and
insert methods, which are overloaded so as to accept data of any type. Each
effectively converts a given datum to a string and then appends or inserts the characters of that
string to the string buffer. The append method always adds these characters at the
end of the buffer; the insert method adds the characters at a specified point.
For example, if z refers to a string buffer object whose current contents are "
start", then the method call z.append("le") would cause the string
buffer to contain " startle", whereas z.insert(4, "le") would alter the
string buffer to contain "starlet".
In general, if sb refers to an instance of a StringBuffer, then
sb.append(x) has the same effect as sb.insert(sb.length(), x).
Whenever an operation occurs involving a source sequence (such as appending or inserting from a source sequence) this class synchronizes only on the string buffer performing the operation, not on the source.
Every string buffer has a capacity. As long as the length of the character sequence contained in the string buffer does not exceed the capacity, it is not necessary to allocate a new internal buffer array. If the internal buffer overflows, it is automatically made larger.
| Constructor and Description |
|---|
StringBuffer()
Constructs a string buffer with no characters in it and an initial capacity of 16 characters.
|
StringBuffer(CharSequence seq)
Constructs a string buffer that contains the same characters as the specified
CharSequence. |
StringBuffer(int capacity)
Constructs a string buffer with no characters in it and the specified initial capacity.
|
StringBuffer(String str)
Constructs a string buffer initialized to the contents of the specified string.
|
| Modifier and Type | Method and Description |
|---|---|
StringBuffer |
append(boolean b)
Appends the string representation of the boolean argument to the sequence.
|
StringBuffer |
append(char c)
Appends the specified character to this Appendable.
|
StringBuffer |
append(char[] str)
Appends the string representation of the char array argument to this
sequence.
|
StringBuffer |
append(char[] str,
int offset,
int len)
Appends the string representation of a subarray of the
char array argument to this
sequence. |
StringBuffer |
append(CharSequence s)
Appends the specified
CharSequence to this sequence. |
StringBuffer |
append(CharSequence s,
int start,
int end)
Appends a subsequence of the specified
CharSequence to this sequence. |
StringBuffer |
append(double d)
Appends the string representation of the double argument to this sequence.
|
StringBuffer |
append(float f)
Appends the string representation of the float argument to this sequence.
|
StringBuffer |
append(int i)
Appends the string representation of the int argument to this sequence.
|
StringBuffer |
append(long lng)
Appends the string representation of the long argument to this sequence.
|
StringBuffer |
append(Object obj)
Appends the string representation of the Object argument.
|
StringBuffer |
append(String str)
Appends the specified string to this character sequence.
|
StringBuffer |
append(StringBuffer sb)
Appends the specified StringBuffer to this sequence.
|
int |
capacity()
Returns the current capacity.
|
char |
charAt(int index)
Returns the
char value in this sequence at the specified index. |
StringBuffer |
delete(int start,
int end)
Removes the characters in a substring of this sequence.
|
StringBuffer |
deleteCharAt(int index)
Removes the
char at the specified position in this sequence. |
void |
ensureCapacity(int minimumCapacity)
Ensures that the capacity is at least equal to the specified minimum.
|
void |
getChars(int srcBegin,
int srcEnd,
char[] dst,
int dstBegin)
Characters are copied from this sequence into the destination character array
dst. |
int |
indexOf(String str)
Returns the index within this string of the first occurrence of the specified substring.
|
int |
indexOf(String str,
int fromIndex)
Returns the index within this string of the first occurrence of the specified substring, starting
at the specified index.
|
StringBuffer |
insert(int offset,
boolean b)
Inserts the string representation of the
boolean argument into this sequence. |
StringBuffer |
insert(int offset,
char c)
Inserts the string representation of the
char argument into this sequence. |
StringBuffer |
insert(int offset,
char[] str)
Inserts the string representation of the
char array argument into this sequence. |
StringBuffer |
insert(int index,
char[] str,
int offset,
int len)
Inserts the string representation of a subarray of the
str array argument into this
sequence. |
StringBuffer |
insert(int dstOffset,
CharSequence s)
Inserts the specified
CharSequence into this sequence. |
StringBuffer |
insert(int dstOffset,
CharSequence s,
int start,
int end)
Inserts a subsequence of the specified
CharSequence into this sequence. |
StringBuffer |
insert(int offset,
double d)
Inserts the string representation of the
double argument into this sequence. |
StringBuffer |
insert(int offset,
float f)
Inserts the string representation of the
float argument into this sequence. |
StringBuffer |
insert(int offset,
int i)
Inserts the string representation of the second
int argument into this sequence. |
StringBuffer |
insert(int offset,
long l)
Inserts the string representation of the
long argument into this sequence. |
StringBuffer |
insert(int offset,
Object obj)
Inserts the string representation of the
Object argument into this character sequence. |
StringBuffer |
insert(int offset,
String str)
Inserts the string into this character sequence.
|
int |
lastIndexOf(String str)
Returns the index within this string of the rightmost occurrence of the specified substring.
|
int |
lastIndexOf(String str,
int fromIndex)
Returns the index within this string of the last occurrence of the specified substring.
|
int |
length()
Returns the length of this character sequence.
|
StringBuffer |
replace(int start,
int end,
String str)
Replaces the characters in a substring of this sequence with characters in the specified
String. |
StringBuffer |
reverse()
Causes this character sequence to be replaced by the reverse of the sequence.
|
void |
setCharAt(int index,
char ch)
The character at the specified index is set to
ch. |
void |
setLength(int newLength)
Sets the length of the character sequence.
|
CharSequence |
subSequence(int start,
int end)
Returns a new character sequence that is a subsequence of this sequence.
|
String |
substring(int start)
Returns a new
String that contains a subsequence of characters currently contained
in this character sequence. |
String |
substring(int start,
int end)
Returns a new
String that contains a subsequence of characters currently contained
in this sequence. |
String |
toString()
Returns a string representation of the object.
|
void |
trimToSize()
Attempts to reduce storage used for the character sequence.
|
public StringBuffer()
public StringBuffer(CharSequence seq)
CharSequence. The initial capacity of the string buffer is 16 plus the
length of the CharSequence argument.
If the length of the specified CharSequence is less than or equal to zero, then an
empty buffer of capacity 16 is returned.
seq - the sequence to copy.NullPointerException - if seq is nullpublic StringBuffer(int capacity)
capacity - the initial capacity.NegativeArraySizeException - if the capacity argument is less than 0.public StringBuffer(String str)
16 plus the length of the string argument.str - the initial contents of the buffer.NullPointerException - if str is nullpublic StringBuffer append(boolean b)
The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(boolean), and the characters of that string were then appended to this character sequence.
b - a boolean.public StringBuffer append(char c)
Appendableappend in interface Appendablec - The character to appendpublic StringBuffer append(char[] str)
The characters of the array argument are appended, in order, to the contents of this sequence. The length of this sequence increases by the length of the argument.
The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(char[]), and the characters of that string were then appended to this character sequence.
str - the characters to be appended.public StringBuffer append(char[] str, int offset, int len)
char array argument to this
sequence.
Characters of the char array str, starting at index offset, are appended,
in order, to the contents of this sequence. The length of this sequence increases by the value of
len.
The overall effect is exactly as if the arguments were converted to a string by the method
String.valueOf(char[],int,int), and the characters of that string were then
appended to this character sequence.
str - the characters to be appended.offset - the index of the first char to append.len - the number of chars to append.IndexOutOfBoundsException - if offset < 0 or len < 0 or offset+len > str.lengthpublic StringBuffer append(@Nullable CharSequence s)
CharSequence to this sequence.
The characters of the CharSequence argument are appended, in order, increasing the
length of this sequence by the length of the argument.
The result of this method is exactly the same as if it were an invocation of this.append(s, 0, s.length());
This method synchronizes on this (the destination) object but does not synchronize on the source
(s).
If s is null, then the four characters "null" are
appended.
append in interface Appendables - the CharSequence to append.public StringBuffer append(@Nullable CharSequence s, int start, int end)
CharSequence to this sequence.
Characters of the argument s, starting at index start, are appended, in order, to
the contents of this sequence up to the (exclusive) index end. The length of this
sequence is increased by the value of end - start.
Let n be the length of this character sequence just prior to execution of the
append method. Then the character at index k in this character sequence becomes
equal to the character at index k in this sequence, if k is less than n;
otherwise, it is equal to the character at index k+start-n in the argument s.
If s is null, then this method appends characters as if the s parameter was a
sequence containing the four characters "null".
append in interface Appendables - the sequence to append.start - the starting index of the subsequence to be appended.end - the end index of the subsequence to be appended.IndexOutOfBoundsException - if start is negative, or start is greater than end or end
is greater than s.length()public StringBuffer append(double d)
The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(double), and the characters of that string were then appended to this character sequence.
d - a double.public StringBuffer append(float f)
The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(float), and the characters of that string were then appended to this character sequence.
f - a float.public StringBuffer append(int i)
The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(int), and the characters of that string were then appended to this character sequence.
i - an int.public StringBuffer append(long lng)
The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(long), and the characters of that string were then appended to this character sequence.
lng - a long.public StringBuffer append(@Nullable Object obj)
The overall effect is exactly as if the argument were converted to a string by the method String.valueOf(Object), and the characters of that string were then appended to this character sequence.
obj - an Object.public StringBuffer append(@Nullable String str)
The characters of the String argument are appended, in order, increasing the length of this sequence by the length of the argument. If str is null, then the four characters "null" are appended.
Let n be the length of this character sequence just prior to execution of the append method. Then the character at index k in the new character sequence is equal to the character at index k in the old character sequence, if k is less than n; otherwise, it is equal to the character at index k-n in the argument str.
str - a String.public StringBuffer append(@Nullable StringBuffer sb)
The characters of the StringBuffer argument are appended, in order, to the contents of this StringBuffer, increasing the length of this StringBuffer by the length of the argument. If sb is null, then the four characters "null" are appended to this StringBuffer.
Let n be the length of the old character sequence, the one contained in the
StringBuffer just prior to execution of the append method. Then the character
at index k in the new character sequence is equal to the character at index k in
the old character sequence, if k is less than n; otherwise, it is equal to the
character at index k-n in the argument sb.
This method synchronizes on this (the destination) object but does not synchronize
on the source (sb).
sb - the StringBuffer to append.public int capacity()
public char charAt(int index)
char value in this sequence at the specified index. The first
char value is at index 0, the next at index 1, and so on,
as in array indexing.
The index argument must be greater than or equal to 0, and less than the length of
this sequence.
charAt in interface CharSequenceindex - the index of the desired char value.char value at the specified index.IndexOutOfBoundsException - if index is negative or greater than or equal to length().length()public StringBuffer delete(int start, int end)
start and extends to the character at index end - 1 or to the end of the sequence
if no such character exists. If start is equal to end, no changes are made.start - The beginning index, inclusive.end - The ending index, exclusive.StringIndexOutOfBoundsException - if start is negative, greater than length(), or greater than end.public StringBuffer deleteCharAt(int index)
char at the specified position in this sequence. This sequence is
shortened by one char.
Note: If the character at the given index is a supplementary character, this method does not
remove the entire character. If correct handling of supplementary characters is required,
determine the number of chars to remove by calling
Character.charCount(thisSequence.codePointAt(index)), where
thisSequence is this sequence.
index - Index of char to removeStringIndexOutOfBoundsException - if the index is negative or greater than or equal to length().public void ensureCapacity(int minimumCapacity)
minimumCapacity argument.
2.
minimumCapacity argument is nonpositive, this method takes no action and
simply returns.minimumCapacity - the minimum desired capacity.public void getChars(int srcBegin,
int srcEnd,
char[] dst,
int dstBegin)
dst.
The first character to be copied is at index srcBegin; the last character to be
copied is at index srcEnd-1. The total number of characters to be copied is
srcEnd-srcBegin. The characters are copied into the subarray of dst
starting at index dstBegin and ending at index:
dstbegin + (srcEnd - srcBegin) - 1
srcBegin - start copying at this offset.srcEnd - stop copying at this offset.dst - the array to copy the data into.dstBegin - offset into dst.NullPointerException - if dst is null.IndexOutOfBoundsException - if any of the following is true:
srcBegin is negative
dstBegin is negative
srcBegin argument is greater than the srcEnd argument.
srcEnd is greater than this.length().
dstBegin+srcEnd-srcBegin is greater than dst.length
public int indexOf(String str)
isthis.toString().startsWith(str, k)
true.str - any string.-1 is returned.NullPointerException - if str is null.public int indexOf(String str, int fromIndex)
If no such value of k exists, then -1 is returned.k >= Math.min(fromIndex, str.length()) && this.toString().startsWith(str, k)
str - the substring for which to search.fromIndex - the index from which to start the search.NullPointerException - if str is null.public StringBuffer insert(int offset, boolean b)
boolean argument into this sequence.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(boolean), and the characters of that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.b - a boolean.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset, char c)
char argument into this sequence.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(char), and the character in that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.c - a char.IndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset, char[] str)
char array argument into this sequence.
The characters of the array argument are inserted into the contents of this sequence at the
position indicated by offset. The length of this sequence increases by the length of the
argument.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(char[]), and the characters of that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.str - a character array.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int index, char[] str, int offset, int len)
str array argument into this
sequence. The subarray begins at the specified offset and extends len
chars. The characters of the subarray are inserted into this sequence at the position
indicated by index. The length of this sequence increases by len char s.index - position at which to insert subarray.str - A char array.offset - the index of the first char in subarray to be inserted.len - the number of chars in the subarray to be inserted.StringIndexOutOfBoundsException - if index is negative or greater than length(), or offset or
len are negative, or (offset+len) is greater than str.length.public StringBuffer insert(int dstOffset, @Nullable CharSequence s)
CharSequence into this sequence.
The characters of the CharSequence argument are inserted, in order, into this sequence at
the indicated offset, moving up any characters originally above that position and increasing the
length of this sequence by the length of the argument s.
The result of this method is exactly the same as if it were an invocation of this object's
insert(dstOffset, s, 0, s.length()) method.
If s is null, then the four characters "null" are inserted into this
sequence.
dstOffset - the offset.s - the sequence to be insertedIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int dstOffset, @Nullable CharSequence s, int start, int end)
CharSequence into this sequence.
The subsequence of the argument s specified by start and end are
inserted, in order, into this sequence at the specified destination offset, moving up any
characters originally above that position. The length of this sequence is increased by
end - start.
The character at index k in this sequence becomes equal to:
dstOffset
+start-dstOffset in the argument s, if
k is greater than or equal to dstOffset but is less than
dstOffset+end-start
-(end-start) in this sequence, if k is greater
than or equal to dstOffset+end-start
The dstOffset argument must be greater than or equal to 0, and less than or equal
to the length of this sequence.
The start argument must be nonnegative, and not greater than end.
The end argument must be greater than or equal to start, and less than or equal to the
length of s.
If s is null, then this method inserts characters as if the s parameter was a
sequence containing the four characters "null".
dstOffset - the offset in this sequence.s - the sequence to be inserted.start - the starting index of the subsequence to be inserted.end - the end index of the subsequence to be inserted.IndexOutOfBoundsException - if dstOffset is negative or greater than this.length(), or start
or end are negative, or start is greater than end or end
is greater than s.length()public StringBuffer insert(int offset, double d)
double argument into this sequence.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(double), and the characters of that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.d - a double.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset, float f)
float argument into this sequence.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(float), and the characters of that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.f - a float.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset, int i)
int argument into this sequence.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(int), and the characters of that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.i - an int.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset, long l)
long argument into this sequence.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(long), and the characters of that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.l - a long.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset, Object obj)
Object argument into this character sequence.
The overall effect is exactly as if the second argument were converted to a string by the method
String.valueOf(Object), and the characters of that string were then
inserted into this character sequence at the indicated offset.
The offset argument must be greater than or equal to 0, and less than or equal to
the length of this sequence.
offset - the offset.obj - an Object.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset, @Nullable String str)
The characters of the String argument are inserted, in order, into
this sequence at the indicated offset, moving up any characters originally
above that position and increasing the length of this sequence by the length
of the argument. If str is null, then the four characters
"null" are inserted into this sequence.
The character at index k in the new character sequence is equal to:
offset
-offset in the argument
str, if k is not less than offset but is less than
offset+str.length()
-str.length() in the old character
sequence, if k is not less than offset+str.length()
The offset argument must be greater than or equal to 0, and
less than or equal to the length of this sequence.
offset - the offset.str - a String.StringIndexOutOfBoundsException - if the offset is invalid.public int lastIndexOf(String str)
this.length().
The returned index is the largest value k such that is true.this.toString().startsWith(str, k)
str - the substring to search for.-1 is returned.NullPointerException - if str is null.public int lastIndexOf(String str, int fromIndex)
If no such value of k exists, then -1 is returned.k <= Math.min(fromIndex, str.length()) && this.toString().startsWith(str, k)
str - the substring to search for.fromIndex - the index to start the search from.NullPointerException - if str is null.public int length()
CharSequencechars in the sequence.length in interface CharSequencechars in this sequencepublic StringBuffer replace(int start, int end, String str)
String. The substring begins at the specified start and extends to the
character at index end - 1 or to the end of the sequence if no such character
exists. First the characters in the substring are removed and then the specified
String is inserted at start. (This sequence will be lengthened to
accommodate the specified String if necessary.)start - The beginning index, inclusive.end - The ending index, exclusive.str - String that will replace previous contents.StringIndexOutOfBoundsException - if start is negative, greater than length(), or greater than
end.public StringBuffer reverse()
char values) just prior to execution of the reverse method. Then the
character at index k in the new character sequence is equal to the character at index
n-k-1 in the old character sequence.public void setCharAt(int index,
char ch)
ch. This sequence is altered to
represent a new character sequence that is identical to the old character sequence, except that
it contains the character ch at position index.
The index argument must be greater than or equal to 0, and less than the length of
this sequence.
index - the index of the character to modify.ch - the new character.IndexOutOfBoundsException - if index is negative or greater than or equal to length().length()public void setLength(int newLength)
newLength, the character at index k in the new character sequence is the same
as the character at index k in the old sequence if k is less than the length of the
old character sequence; otherwise, it is the null character '\u0000'.
In other words, if the newLength argument is less than the current length, the
length is changed to the specified length.
If the newLength argument is greater than or equal to the current length, sufficient
null characters ('\u0000') are appended so that length becomes the
newLength argument.
The newLength argument must be greater than or equal to 0.
newLength - the new lengthIndexOutOfBoundsException - if the newLength argument is negative.length()public CharSequence subSequence(int start, int end)
An invocation of this method of the form
behaves in exactly the same way as the invocationsb.subSequence(begin, end)
This method is provided so that this class can implement thesb.substring(begin, end)
CharSequence interface.subSequence in interface CharSequencestart - the start index, inclusive.end - the end index, exclusive.IndexOutOfBoundsException - if start or end are negative, if end is greater than
length(), or if start is greater than endpublic String substring(int start)
String that contains a subsequence of characters currently contained
in this character sequence. The substring begins at the specified index and extends to the end of
this sequence.start - The beginning index, inclusive.StringIndexOutOfBoundsException - if start is less than zero, or greater than the length of this object.public String substring(int start, int end)
String that contains a subsequence of characters currently contained
in this sequence. The substring begins at the specified start and extends to the
character at index end - 1.start - The beginning index, inclusive.end - The ending index, exclusive.StringIndexOutOfBoundsException - if start or end are negative or greater than
length(), or start is greater than end.public String toString()
ObjecttoString method returns a
string that "textually represents" this object. The result should be a concise but informative
representation that is easy for a person to read. It is recommended that all subclasses override
this method.
The toString method for class Object returns a string consisting of the name of
the class of which the object is an instance, the at-sign character `@', and the unsigned
hexadecimal representation of the hash code of the object. In other words, this method returns a
string equal to the value of:
getClass().getName() + '@' + Integer.toHexString(hashCode())
toString in interface CharSequencetoString in class Objectpublic void trimToSize()
capacity() method.