public final classStringBufferextendsObjectimplementsSerializable,CharSequence
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 aStringBuffer are theappend andinsert 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. Theappend method always adds these characters at the end of the buffer; theinsert method adds the characters at a specified point.
For example, ifz refers to a string buffer object whose current contents are"start", then the method callz.append("le") would cause the string buffer to contain"startle", whereasz.insert(4, "le") would alter the string buffer to contain"starlet".
In general, if sb refers to an instance of aStringBuffer, thensb.append(x) has the same effect assb.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. Note that whileStringBuffer is designed to be safe to use concurrently from multiple threads, if the constructor or theappend orinsert operation is passed a source sequence that is shared across threads, the calling code must ensure that the operation has a consistent and unchanging view of the source sequence for the duration of the operation. This could be satisfied by the caller holding a lock during the operation's call, by using an immutable source sequence, or by not sharing the source sequence across threads.
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.
Unless otherwise noted, passing anull argument to a constructor or method in this class will cause aNullPointerException to be thrown.
As of release JDK 5, this class has been supplemented with an equivalent class designed for use by a single thread,StringBuilder. TheStringBuilder class should generally be used in preference to this one, as it supports all of the same operations but it is faster, as it performs no synchronization.
StringBuilder,String,Serialized Form| Constructor | 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 | Description |
|---|---|---|
StringBuffer | append(boolean b) | Appends the string representation of the boolean argument to the sequence. |
StringBuffer | append(char c) | Appends the string representation of the char argument to this sequence. |
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. |
StringBuffer | appendCodePoint(int codePoint) | Appends the string representation of the codePoint argument to this sequence. |
int | capacity() | Returns the current capacity. |
char | charAt(int index) | Returns the char value in this sequence at the specified index. |
int | codePointAt(int index) | Returns the character (Unicode code point) at the specified index. |
int | codePointBefore(int index) | Returns the character (Unicode code point) before the specified index. |
int | codePointCount(int beginIndex, int endIndex) | Returns the number of Unicode code points in the specified text range of this sequence. |
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 (character count). |
int | offsetByCodePoints(int index, int codePointOffset) | Returns the index within this sequence that is offset from the given index bycodePointOffset code points. |
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 representing the data in this sequence. |
void | trimToSize() | Attempts to reduce storage used for the character sequence. |
clone,equals,finalize,getClass,hashCode,notify,notifyAll,wait,wait,waitchars,codePointspublic StringBuffer()
public StringBuffer(int capacity)
capacity - the initial capacity.NegativeArraySizeException - if thecapacity argument is less than0.public StringBuffer(String str)
16 plus the length of the string argument.str - the initial contents of the buffer.public StringBuffer(CharSequence seq)
CharSequence. The initial capacity of the string buffer is16 plus the length of theCharSequence argument. If the length of the specifiedCharSequence is less than or equal to zero, then an empty buffer of capacity16 is returned.
seq - the sequence to copy.public int length()
length in interface CharSequencepublic int capacity()
public void ensureCapacity(int minimumCapacity)
minimumCapacity argument.2.minimumCapacity argument is nonpositive, this method takes no action and simply returns. Note that subsequent operations on this object can reduce the actual capacity below that requested here.minimumCapacity - the minimum desired capacity.public void trimToSize()
capacity() method.public void setLength(int newLength)
newLength, the character at indexk in the new character sequence is the same as the character at indexk in the old sequence ifk is less than the length of the old character sequence; otherwise, it is the null character'\u0000'. In other words, if thenewLength argument is less than the current length, the length is changed to the specified length. If thenewLength argument is greater than or equal to the current length, sufficient null characters ('\u0000') are appended so that length becomes thenewLength argument.
ThenewLength argument must be greater than or equal to0.
newLength - the new lengthIndexOutOfBoundsException - if thenewLength argument is negative.length()public char charAt(int index)
char value in this sequence at the specified index. The firstchar value is at index0, the next at index1, and so on, as in array indexing. The index argument must be greater than or equal to0, and less than the length of this sequence.
If thechar value specified by the index is asurrogate, the surrogate value is returned.
charAt in interface CharSequenceindex - the index of the desiredchar value.char value at the specified index.IndexOutOfBoundsException - ifindex is negative or greater than or equal tolength().length()public int codePointAt(int index)
char values (Unicode code units) and ranges from0 tolength()- 1. If thechar value specified at the given index is in the high-surrogate range, the following index is less than the length of this sequence, and thechar value at the following index is in the low-surrogate range, then the supplementary code point corresponding to this surrogate pair is returned. Otherwise, thechar value at the given index is returned.
index - the index to thechar valuesindexpublic int codePointBefore(int index)
char values (Unicode code units) and ranges from1 tolength(). If thechar value at(index - 1) is in the low-surrogate range,(index - 2) is not negative, and thechar value at(index - 2) is in the high-surrogate range, then the supplementary code point value of the surrogate pair is returned. If thechar value atindex - 1 is an unpaired low-surrogate or a high-surrogate, the surrogate value is returned.
index - the index following the code point that should be returnedpublic int codePointCount(int beginIndex, int endIndex)
beginIndex and extends to thechar at indexendIndex - 1. Thus the length (inchars) of the text range isendIndex-beginIndex. Unpaired surrogates within this sequence count as one code point each.beginIndex - the index to the firstchar of the text range.endIndex - the index after the lastchar of the text range.public int offsetByCodePoints(int index, int codePointOffset)
index bycodePointOffset code points. Unpaired surrogates within the text range given byindex andcodePointOffset count as one code point each.index - the index to be offsetcodePointOffset - the offset in code pointspublic void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
dst. The first character to be copied is at indexsrcBegin; the last character to be copied is at indexsrcEnd-1. The total number of characters to be copied issrcEnd-srcBegin. The characters are copied into the subarray ofdst starting at indexdstBegin and ending at index: dstbegin + (srcEnd-srcBegin) - 1srcBegin - start copying at this offset.srcEnd - stop copying at this offset.dst - the array to copy the data into.dstBegin - offset intodst.IndexOutOfBoundsException - if any of the following is true:srcBegin is negativedstBegin is negativesrcBegin argument is greater than thesrcEnd argument.srcEnd is greater thanthis.length().dstBegin+srcEnd-srcBegin is greater thandst.lengthpublic 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 characterch at positionindex. The index argument must be greater than or equal to0, and less than the length of this sequence.
index - the index of the character to modify.ch - the new character.IndexOutOfBoundsException - ifindex is negative or greater than or equal tolength().length()public StringBuffer append(Object obj)
Object argument. The overall effect is exactly as if the argument were converted to a string by the methodString.valueOf(Object), and the characters of that string were thenappended to this character sequence.
obj - anObject.public StringBuffer append(String str)
The characters of theString argument are appended, in order, increasing the length of this sequence by the length of the argument. Ifstr isnull, then the four characters"null" are appended.
Letn be the length of this character sequence just prior to execution of theappend method. Then the character at indexk in the new character sequence is equal to the character at indexk in the old character sequence, ifk is less thann; otherwise, it is equal to the character at indexk-n in the argumentstr.
str - a string.public StringBuffer append(StringBuffer sb)
StringBuffer to this sequence. The characters of theStringBuffer argument are appended, in order, to the contents of thisStringBuffer, increasing the length of thisStringBuffer by the length of the argument. Ifsb isnull, then the four characters"null" are appended to thisStringBuffer.
Letn be the length of the old character sequence, the one contained in theStringBuffer just prior to execution of theappend method. Then the character at indexk in the new character sequence is equal to the character at indexk in the old character sequence, ifk is less thann; otherwise, it is equal to the character at indexk-n in the argumentsb.
This method synchronizes onthis, the destination object, but does not synchronize on the source (sb).
sb - theStringBuffer to append.public StringBuffer append(CharSequence s)
CharSequence to this sequence. The characters of theCharSequence 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 onthis, the destination object, but does not synchronize on the source (s).
Ifs isnull, then the four characters"null" are appended.
append in interface Appendables - theCharSequence to append.public StringBuffer append(CharSequence s, int start, int end)
CharSequence to this sequence. Characters of the arguments, starting at indexstart, are appended, in order, to the contents of this sequence up to the (exclusive) indexend. The length of this sequence is increased by the value ofend - start.
Letn be the length of this character sequence just prior to execution of theappend method. Then the character at indexk in this character sequence becomes equal to the character at indexk in this sequence, ifk is less thann; otherwise, it is equal to the character at indexk+start-n in the arguments.
Ifs isnull, 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 - ifstart is negative, orstart is greater thanend orend is greater thans.length()public StringBuffer append(char[] str)
char array argument to this sequence.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 methodString.valueOf(char[]), and the characters of that string were thenappended 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 thechar arraystr, starting at indexoffset, are appended, in order, to the contents of this sequence. The length of this sequence increases by the value oflen.
The overall effect is exactly as if the arguments were converted to a string by the methodString.valueOf(char[],int,int), and the characters of that string were thenappended to this character sequence.
str - the characters to be appended.offset - the index of the firstchar to append.len - the number ofchars to append.IndexOutOfBoundsException - ifoffset < 0 orlen < 0 oroffset+len > str.lengthpublic StringBuffer append(boolean b)
boolean argument to the sequence. The overall effect is exactly as if the argument were converted to a string by the methodString.valueOf(boolean), and the characters of that string were thenappended to this character sequence.
b - aboolean.public StringBuffer append(char c)
char argument to this sequence. The argument is appended to the contents of this sequence. The length of this sequence increases by1.
The overall effect is exactly as if the argument were converted to a string by the methodString.valueOf(char), and the character in that string were thenappended to this character sequence.
append in interface Appendablec - achar.public StringBuffer append(int i)
int argument to this sequence. The overall effect is exactly as if the argument were converted to a string by the methodString.valueOf(int), and the characters of that string were thenappended to this character sequence.
i - anint.public StringBuffer appendCodePoint(int codePoint)
codePoint argument to this sequence. The argument is appended to the contents of this sequence. The length of this sequence increases byCharacter.charCount(codePoint).
The overall effect is exactly as if the argument were converted to achar array by the methodCharacter.toChars(int) and the character in that array were thenappended to this character sequence.
codePoint - a Unicode code pointpublic StringBuffer append(long lng)
long argument to this sequence. The overall effect is exactly as if the argument were converted to a string by the methodString.valueOf(long), and the characters of that string were thenappended to this character sequence.
lng - along.public StringBuffer append(float f)
float argument to this sequence. The overall effect is exactly as if the argument were converted to a string by the methodString.valueOf(float), and the characters of that string were thenappended to this character sequence.
f - afloat.public StringBuffer append(double d)
double argument to this sequence. The overall effect is exactly as if the argument were converted to a string by the methodString.valueOf(double), and the characters of that string were thenappended to this character sequence.
d - adouble.public StringBuffer delete(int start, int end)
start and extends to the character at indexend - 1 or to the end of the sequence if no such character exists. Ifstart is equal toend, no changes are made.start - The beginning index, inclusive.end - The ending index, exclusive.StringIndexOutOfBoundsException - ifstart is negative, greater thanlength(), or greater thanend.public StringBuffer deleteCharAt(int index)
char at the specified position in this sequence. This sequence is shortened by onechar.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 ofchars to remove by callingCharacter.charCount(thisSequence.codePointAt(index)), wherethisSequence is this sequence.
index - Index ofchar to removeStringIndexOutOfBoundsException - if theindex is negative or greater than or equal tolength().public StringBuffer replace(int start, int end,String str)
String. The substring begins at the specifiedstart and extends to the character at indexend - 1 or to the end of the sequence if no such character exists. First the characters in the substring are removed and then the specifiedString is inserted atstart. (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 - ifstart is negative, greater thanlength(), or greater thanend.public 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 - ifstart is less than zero, or greater than the length of this object.public CharSequence subSequence(int start, int end)
An invocation of this method of the form
sb.subSequence(begin, end) sb.substring(begin, end)CharSequence interface.subSequence in interface CharSequencestart - the start index, inclusive.end - the end index, exclusive.IndexOutOfBoundsException - ifstart orend are negative, ifend is greater thanlength(), or ifstart is greater thanendpublic String substring(int start, int end)
String that contains a subsequence of characters currently contained in this sequence. The substring begins at the specifiedstart and extends to the character at indexend - 1.start - The beginning index, inclusive.end - The ending index, exclusive.StringIndexOutOfBoundsException - ifstart orend are negative or greater thanlength(), orstart is greater thanend.public StringBuffer insert(int index, char[] str, int offset, int len)
str array argument into this sequence. The subarray begins at the specifiedoffset and extendslenchars. The characters of the subarray are inserted into this sequence at the position indicated byindex. The length of this sequence increases bylenchars.index - position at which to insert subarray.str - Achar array.offset - the index of the firstchar in subarray to be inserted.len - the number ofchars in the subarray to be inserted.StringIndexOutOfBoundsException - ifindex is negative or greater thanlength(), oroffset orlen are negative, or(offset+len) is greater thanstr.length.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 methodString.valueOf(Object), and the characters of that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.obj - anObject.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int offset,String str)
The characters of theString 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. Ifstr isnull, then the four characters"null" are inserted into this sequence.
The character at indexk in the new character sequence is equal to:
offset-offset in the argumentstr, ifk is not less thanoffset but is less thanoffset+str.length()-str.length() in the old character sequence, ifk is not less thanoffset+str.length() Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.str - a string.StringIndexOutOfBoundsException - 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 byoffset. 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 methodString.valueOf(char[]), and the characters of that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.str - a character array.StringIndexOutOfBoundsException - if the offset is invalid.public StringBuffer insert(int dstOffset,CharSequence s)
CharSequence into this sequence. The characters of theCharSequence 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'sinsert(dstOffset, s, 0, s.length()) method.
Ifs isnull, 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,CharSequence s, int start, int end)
CharSequence into this sequence. The subsequence of the arguments specified bystart andend 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 byend - start.
The character at indexk in this sequence becomes equal to:
dstOffset+start-dstOffset in the arguments, ifk is greater than or equal todstOffset but is less thandstOffset+end-start-(end-start) in this sequence, ifk is greater than or equal todstOffset+end-start ThedstOffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
The start argument must be nonnegative, and not greater thanend.
The end argument must be greater than or equal tostart, and less than or equal to the length of s.
Ifs isnull, 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 - ifdstOffset is negative or greater thanthis.length(), orstart orend are negative, orstart is greater thanend orend is greater thans.length()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 methodString.valueOf(boolean), and the characters of that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.b - aboolean.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 methodString.valueOf(char), and the character in that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.c - achar.IndexOutOfBoundsException - 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 methodString.valueOf(int), and the characters of that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.i - anint.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 methodString.valueOf(long), and the characters of that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.l - along.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 methodString.valueOf(float), and the characters of that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.f - afloat.StringIndexOutOfBoundsException - if the offset is invalid.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 methodString.valueOf(double), and the characters of that string were theninserted into this character sequence at the indicated offset.
Theoffset argument must be greater than or equal to0, and less than or equal to thelength of this sequence.
offset - the offset.d - adouble.StringIndexOutOfBoundsException - if the offset is invalid.public int indexOf(String str)
this.toString().startsWith(str, <i>k</i>)true.str - any string.-1 is returned.public int indexOf(String str, int fromIndex)
k for which: k >= Math.min(fromIndex, this.length()) && this.toString().startsWith(str, k)str - the substring for which to search.fromIndex - the index from which to start the search.public int lastIndexOf(String str)
this.length(). The returned index is the largest valuek such that this.toString().startsWith(str, k)str - the substring to search for.-1 is returned.public int lastIndexOf(String str, int fromIndex)
k <= Math.min(fromIndex, this.length()) && this.toString().startsWith(str, k)str - the substring to search for.fromIndex - the index to start the search from.public StringBuffer reverse()
char values) just prior to execution of thereverse method. Then the character at indexk in the new character sequence is equal to the character at indexn-k-1 in the old character sequence.Note that the reverse operation may result in producing surrogate pairs that were unpaired low-surrogates and high-surrogates before the operation. For example, reversing "\uDC00\uD800" produces "\uD800\uDC00" which is a valid surrogate pair.
public String toString()
String object is allocated and initialized to contain the character sequence currently represented by this object. ThisString is then returned. Subsequent changes to this sequence do not affect the contents of theString.toString in interface CharSequence