StringBuffer represents a changeable String.
* It provides the operations required to modify the
* StringBuffer, including insert, replace, delete, append,
* and reverse. It is thread-safe; meaning that all modifications to a buffer
* are in synchronized methods.
*
* StringBuffers are variable-length in nature, so even if
* you initialize them to a certain size, they can still grow larger than
* that. Capacity indicates the number of characters the
* StringBuffer can have in it before it has to grow (growing
* the char array is an expensive operation involving new).
*
*
Incidentally, compilers often implement the String operator "+"
* by using a StringBuffer operation:
* a + b
* is the same as
* new StringBuffer().append(a).append(b).toString().
*
*
Classpath's StringBuffer is capable of sharing memory with Strings for
* efficiency. This will help when a StringBuffer is converted to a String
* and the StringBuffer is not changed after that (quite common when performing
* string concatenation).
*
* @author Paul Fisher
* @author John Keiser
* @author Tom Tromey
* @author Eric Blake (ebb9@email.byu.edu)
* @see String
* @since 1.0
* @status updated to 1.4
*/
public final class StringBuffer
implements Serializable, CharSequence, Appendable
{
// Implementation note: if you change this class, you usually will
// want to change StringBuilder as well.
/**
* Compatible with JDK 1.0+.
*/
private static final long serialVersionUID = 3388685877147921107L;
/**
* Index of next available character (and thus the size of the current
* string contents). Note that this has permissions set this way so that
* String can get the value.
*
* @serial the number of characters in the buffer
*/
int count;
/**
* The buffer. Note that this has permissions set this way so that String
* can get the value.
*
* @serial the buffer
*/
char[] value;
/**
* True if the buffer is shared with another object (StringBuffer or
* String); this means the buffer must be copied before writing to it again.
* Note that this has permissions set this way so that String can get the
* value.
*
* @serial whether the buffer is shared
*/
boolean shared;
/**
* The default capacity of a buffer.
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* Create a new StringBuffer with default capacity 16.
*/
public StringBuffer()
{
this(DEFAULT_CAPACITY);
}
/**
* Create an empty StringBuffer with the specified initial
* capacity.
*
* @param capacity the initial capacity
* @throws NegativeArraySizeException if capacity is negative
*/
public StringBuffer(int capacity)
{
value = new char[capacity];
}
/**
* Create a new StringBuffer with the characters in the
* specified String. Initial capacity will be the size of the
* String plus 16.
*
* @param str the String to convert
* @throws NullPointerException if str is null
*/
public StringBuffer(String str)
{
// Unfortunately, because the size is 16 larger, we cannot share.
count = str.count;
value = new char[count + DEFAULT_CAPACITY];
str.getChars(0, count, value, 0);
}
/**
* Create a new StringBuffer with the characters from the
* specified CharSequence. Initial capacity will be the
* size of the CharSequence plus 16.
*
* @param seq the String to convert
* @throws NullPointerException if str is null
* @since 1.5
*/
public StringBuffer(CharSequence seq)
{
count = Math.max(0, seq.length());
value = new char[count + DEFAULT_CAPACITY];
for (int i = 0; i < count; ++i)
value[i] = seq.charAt(i);
}
/**
* Get the length of the String this StringBuffer
* would create. Not to be confused with the capacity of the
* StringBuffer.
*
* @return the length of this StringBuffer
* @see #capacity()
* @see #setLength(int)
*/
public synchronized int length()
{
return count;
}
/**
* Get the total number of characters this StringBuffer can
* support before it must be grown. Not to be confused with length.
*
* @return the capacity of this StringBuffer
* @see #length()
* @see #ensureCapacity(int)
*/
public synchronized int capacity()
{
return value.length;
}
/**
* Increase the capacity of this StringBuffer. This will
* ensure that an expensive growing operation will not occur until
* minimumCapacity is reached. The buffer is grown to the
* larger of minimumCapacity and
* capacity() * 2 + 2, if it is not already large enough.
*
* @param minimumCapacity the new capacity
* @see #capacity()
*/
public synchronized void ensureCapacity(int minimumCapacity)
{
ensureCapacity_unsynchronized(minimumCapacity);
}
/**
* Set the length of this StringBuffer. If the new length is greater than
* the current length, all the new characters are set to '\0'. If the new
* length is less than the current length, the first newLength
* characters of the old array will be preserved, and the remaining
* characters are truncated.
*
* @param newLength the new length
* @throws IndexOutOfBoundsException if the new length is negative
* (while unspecified, this is a StringIndexOutOfBoundsException)
* @see #length()
*/
public synchronized void setLength(int newLength)
{
if (newLength < 0)
throw new StringIndexOutOfBoundsException(newLength);
int valueLength = value.length;
/* Always call ensureCapacity_unsynchronized in order to preserve
copy-on-write semantics. */
ensureCapacity_unsynchronized(newLength);
if (newLength < valueLength)
{
/* If the StringBuffer's value just grew, then we know that
value is newly allocated and the region between count and
newLength is filled with '\0'. */
count = newLength;
}
else
{
/* The StringBuffer's value doesn't need to grow. However,
we should clear out any cruft that may exist. */
while (count < newLength)
value[count++] = '\0';
}
}
/**
* Get the character at the specified index.
*
* @param index the index of the character to get, starting at 0
* @return the character at the specified index
* @throws IndexOutOfBoundsException if index is negative or >= length()
*/
public synchronized char charAt(int index)
{
if (index < 0 || index >= count)
throw new StringIndexOutOfBoundsException(index);
return value[index];
}
/**
* Get the code point at the specified index. This is like #charAt(int),
* but if the character is the start of a surrogate pair, and the
* following character completes the pair, then the corresponding
* supplementary code point is returned.
* @param index the index of the codepoint to get, starting at 0
* @return the codepoint at the specified index
* @throws IndexOutOfBoundsException if index is negative or >= length()
* @since 1.5
*/
public synchronized int codePointAt(int index)
{
return Character.codePointAt(value, index, count);
}
/**
* Get the code point before the specified index. This is like
* #codePointAt(int), but checks the characters at index-1 and
* index-2 to see if they form a supplementary code point.
* @param index the index just past the codepoint to get, starting at 0
* @return the codepoint at the specified index
* @throws IndexOutOfBoundsException if index is negative or >= length()
* @since 1.5
*/
public synchronized int codePointBefore(int index)
{
// Character.codePointBefore() doesn't perform this check. We
// could use the CharSequence overload, but this is just as easy.
if (index >= count)
throw new IndexOutOfBoundsException();
return Character.codePointBefore(value, index, 1);
}
/**
* Get the specified array of characters. srcOffset - srcEnd
* characters will be copied into the array you pass in.
*
* @param srcOffset the index to start copying from (inclusive)
* @param srcEnd the index to stop copying from (exclusive)
* @param dst the array to copy into
* @param dstOffset the index to start copying into
* @throws NullPointerException if dst is null
* @throws IndexOutOfBoundsException if any source or target indices are
* out of range (while unspecified, source problems cause a
* StringIndexOutOfBoundsException, and dest problems cause an
* ArrayIndexOutOfBoundsException)
* @see System#arraycopy(Object, int, Object, int, int)
*/
public synchronized void getChars(int srcOffset, int srcEnd,
char[] dst, int dstOffset)
{
if (srcOffset < 0 || srcEnd > count || srcEnd < srcOffset)
throw new StringIndexOutOfBoundsException();
System.arraycopy(value, srcOffset, dst, dstOffset, srcEnd - srcOffset);
}
/**
* Set the character at the specified index.
*
* @param index the index of the character to set starting at 0
* @param ch the value to set that character to
* @throws IndexOutOfBoundsException if index is negative or >= length()
* (while unspecified, this is a StringIndexOutOfBoundsException)
*/
public synchronized void setCharAt(int index, char ch)
{
if (index < 0 || index >= count)
throw new StringIndexOutOfBoundsException(index);
// Call ensureCapacity to enforce copy-on-write.
ensureCapacity_unsynchronized(count);
value[index] = ch;
}
/**
* Append the String value of the argument to this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param obj the Object to convert and append
* @return this StringBuffer
* @see String#valueOf(Object)
* @see #append(String)
*/
public StringBuffer append(Object obj)
{
return append(obj == null ? "null" : obj.toString());
}
/**
* Append the String to this StringBuffer. If
* str is null, the String "null" is appended.
*
* @param str the String to append
* @return this StringBuffer
*/
public synchronized StringBuffer append(String str)
{
if (str == null)
str = "null";
int len = str.count;
ensureCapacity_unsynchronized(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
/**
* Append the StringBuffer value of the argument to this
* StringBuffer. This behaves the same as
* append((Object) stringBuffer), except it is more efficient.
*
* @param stringBuffer the StringBuffer to convert and append
* @return this StringBuffer
* @see #append(Object)
* @since 1.4
*/
public synchronized StringBuffer append(StringBuffer stringBuffer)
{
if (stringBuffer == null)
return append("null");
synchronized (stringBuffer)
{
int len = stringBuffer.count;
ensureCapacity_unsynchronized(count + len);
System.arraycopy(stringBuffer.value, 0, value, count, len);
count += len;
}
return this;
}
/**
* Append the char array to this StringBuffer.
* This is similar (but more efficient) than
* append(new String(data)), except in the case of null.
*
* @param data the char[] to append
* @return this StringBuffer
* @throws NullPointerException if str is null
* @see #append(char[], int, int)
*/
public StringBuffer append(char[] data)
{
return append(data, 0, data.length);
}
/**
* Append part of the char array to this
* StringBuffer. This is similar (but more efficient) than
* append(new String(data, offset, count)), except in the case
* of null.
*
* @param data the char[] to append
* @param offset the start location in str
* @param count the number of characters to get from str
* @return this StringBuffer
* @throws NullPointerException if str is null
* @throws IndexOutOfBoundsException if offset or count is out of range
* (while unspecified, this is a StringIndexOutOfBoundsException)
*/
public synchronized StringBuffer append(char[] data, int offset, int count)
{
if (offset < 0 || count < 0 || offset > data.length - count)
throw new StringIndexOutOfBoundsException();
ensureCapacity_unsynchronized(this.count + count);
System.arraycopy(data, offset, value, this.count, count);
this.count += count;
return this;
}
/**
* Append the code point to this StringBuffer.
* This is like #append(char), but will append two characters
* if a supplementary code point is given.
*
* @param code the code point to append
* @return this StringBuffer
* @see Character#toChars(int, char[], int)
* @since 1.5
*/
public synchronized StringBuffer appendCodePoint(int code)
{
int len = Character.charCount(code);
ensureCapacity_unsynchronized(count + len);
Character.toChars(code, value, count);
count += len;
return this;
}
/**
* Append the String value of the argument to this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param bool the boolean to convert and append
* @return this StringBuffer
* @see String#valueOf(boolean)
*/
public StringBuffer append(boolean bool)
{
return append(bool ? "true" : "false");
}
/**
* Append the char to this StringBuffer.
*
* @param ch the char to append
* @return this StringBuffer
*/
public synchronized StringBuffer append(char ch)
{
ensureCapacity_unsynchronized(count + 1);
value[count++] = ch;
return this;
}
/**
* Append the CharSequence value of the argument to this
* StringBuffer.
*
* @param seq the CharSequence to append
* @return this StringBuffer
* @see #append(Object)
* @since 1.5
*/
public synchronized StringBuffer append(CharSequence seq)
{
if (seq == null)
seq = "null";
return append(seq, 0, seq.length());
}
/**
* Append the specified subsequence of the CharSequence
* argument to this StringBuffer.
*
* @param seq the CharSequence to append
* @param start the starting index
* @param end one past the ending index
* @return this StringBuffer
* @see #append(Object)
* @since 1.5
*/
public synchronized StringBuffer append(CharSequence seq, int start, int end)
{
if (seq == null)
seq = "null";
if (start < 0 || end < 0 || start > end || end > seq.length())
throw new IndexOutOfBoundsException();
ensureCapacity_unsynchronized(this.count + end - start);
for (int i = start; i < end; ++i)
value[count++] = seq.charAt(i);
return this;
}
/**
* Append the String value of the argument to this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param inum the int to convert and append
* @return this StringBuffer
* @see String#valueOf(int)
*/
// GCJ LOCAL: this is native for efficiency.
public native StringBuffer append (int inum);
/**
* Append the String value of the argument to this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param lnum the long to convert and append
* @return this StringBuffer
* @see String#valueOf(long)
*/
public StringBuffer append(long lnum)
{
return append(Long.toString(lnum, 10));
}
/**
* Append the String value of the argument to this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param fnum the float to convert and append
* @return this StringBuffer
* @see String#valueOf(float)
*/
public StringBuffer append(float fnum)
{
return append(Float.toString(fnum));
}
/**
* Append the String value of the argument to this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param dnum the double to convert and append
* @return this StringBuffer
* @see String#valueOf(double)
*/
public StringBuffer append(double dnum)
{
return append(Double.toString(dnum));
}
/**
* Delete characters from this StringBuffer.
* delete(10, 12) will delete 10 and 11, but not 12. It is
* harmless for end to be larger than length().
*
* @param start the first character to delete
* @param end the index after the last character to delete
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if start or end are out of bounds
* @since 1.2
*/
public synchronized StringBuffer delete(int start, int end)
{
if (start < 0 || start > count || start > end)
throw new StringIndexOutOfBoundsException(start);
if (end > count)
end = count;
// This will unshare if required.
ensureCapacity_unsynchronized(count);
if (count - end != 0)
System.arraycopy(value, end, value, start, count - end);
count -= end - start;
return this;
}
/**
* Delete a character from this StringBuffer.
*
* @param index the index of the character to delete
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if index is out of bounds
* @since 1.2
*/
public StringBuffer deleteCharAt(int index)
{
return delete(index, index + 1);
}
/**
* Replace characters between index start (inclusive) and
* end (exclusive) with str. If end
* is larger than the size of this StringBuffer, all characters after
* start are replaced.
*
* @param start the beginning index of characters to delete (inclusive)
* @param end the ending index of characters to delete (exclusive)
* @param str the new String to insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if start or end are out of bounds
* @throws NullPointerException if str is null
* @since 1.2
*/
public synchronized StringBuffer replace(int start, int end, String str)
{
if (start < 0 || start > count || start > end)
throw new StringIndexOutOfBoundsException(start);
int len = str.count;
// Calculate the difference in 'count' after the replace.
int delta = len - (end > count ? count : end) + start;
ensureCapacity_unsynchronized(count + delta);
if (delta != 0 && end < count)
System.arraycopy(value, end, value, end + delta, count - end);
str.getChars(0, len, value, start);
count += delta;
return this;
}
/**
* Creates a substring of this StringBuffer, starting at a specified index
* and ending at the end of this StringBuffer.
*
* @param beginIndex index to start substring (base 0)
* @return new String which is a substring of this StringBuffer
* @throws StringIndexOutOfBoundsException if beginIndex is out of bounds
* @see #substring(int, int)
* @since 1.2
*/
public String substring(int beginIndex)
{
return substring(beginIndex, count);
}
/**
* Creates a substring of this StringBuffer, starting at a specified index
* and ending at one character before a specified index. This is implemented
* the same as substring(beginIndex, endIndex), to satisfy
* the CharSequence interface.
*
* @param beginIndex index to start at (inclusive, base 0)
* @param endIndex index to end at (exclusive)
* @return new String which is a substring of this StringBuffer
* @throws IndexOutOfBoundsException if beginIndex or endIndex is out of
* bounds
* @see #substring(int, int)
* @since 1.4
*/
public CharSequence subSequence(int beginIndex, int endIndex)
{
return substring(beginIndex, endIndex);
}
/**
* Creates a substring of this StringBuffer, starting at a specified index
* and ending at one character before a specified index.
*
* @param beginIndex index to start at (inclusive, base 0)
* @param endIndex index to end at (exclusive)
* @return new String which is a substring of this StringBuffer
* @throws StringIndexOutOfBoundsException if beginIndex or endIndex is out
* of bounds
* @since 1.2
*/
public synchronized String substring(int beginIndex, int endIndex)
{
int len = endIndex - beginIndex;
if (beginIndex < 0 || endIndex > count || endIndex < beginIndex)
throw new StringIndexOutOfBoundsException();
if (len == 0)
return "";
// Don't copy unless substring is smaller than 1/4 of the buffer.
boolean share_buffer = ((len << 2) >= value.length);
if (share_buffer)
this.shared = true;
// Package constructor avoids an array copy.
return new String(value, beginIndex, len, share_buffer);
}
/**
* Insert a subarray of the char[] argument into this
* StringBuffer.
*
* @param offset the place to insert in this buffer
* @param str the char[] to insert
* @param str_offset the index in str to start inserting from
* @param len the number of characters to insert
* @return this StringBuffer
* @throws NullPointerException if str is null
* @throws StringIndexOutOfBoundsException if any index is out of bounds
* @since 1.2
*/
public synchronized StringBuffer insert(int offset,
char[] str, int str_offset, int len)
{
if (offset < 0 || offset > count || len < 0
|| str_offset < 0 || str_offset > str.length - len)
throw new StringIndexOutOfBoundsException();
ensureCapacity_unsynchronized(count + len);
System.arraycopy(value, offset, value, offset + len, count - offset);
System.arraycopy(str, str_offset, value, offset, len);
count += len;
return this;
}
/**
* Insert the String value of the argument into this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param offset the place to insert in this buffer
* @param obj the Object to convert and insert
* @return this StringBuffer
* @exception StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(Object)
*/
public StringBuffer insert(int offset, Object obj)
{
return insert(offset, obj == null ? "null" : obj.toString());
}
/**
* Insert the String argument into this
* StringBuffer. If str is null, the String "null" is used
* instead.
*
* @param offset the place to insert in this buffer
* @param str the String to insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if offset is out of bounds
*/
public synchronized StringBuffer insert(int offset, String str)
{
if (offset < 0 || offset > count)
throw new StringIndexOutOfBoundsException(offset);
if (str == null)
str = "null";
int len = str.count;
ensureCapacity_unsynchronized(count + len);
System.arraycopy(value, offset, value, offset + len, count - offset);
str.getChars(0, len, value, offset);
count += len;
return this;
}
/**
* Insert the CharSequence argument into this
* StringBuffer. If the sequence is null, the String
* "null" is used instead.
*
* @param offset the place to insert in this buffer
* @param sequence the CharSequence to insert
* @return this StringBuffer
* @throws IndexOutOfBoundsException if offset is out of bounds
* @since 1.5
*/
public synchronized StringBuffer insert(int offset, CharSequence sequence)
{
if (sequence == null)
sequence = "null";
return insert(offset, sequence, 0, sequence.length());
}
/**
* Insert a subsequence of the CharSequence argument into this
* StringBuffer. If the sequence is null, the String
* "null" is used instead.
*
* @param offset the place to insert in this buffer
* @param sequence the CharSequence to insert
* @param start the starting index of the subsequence
* @param end one past the ending index of the subsequence
* @return this StringBuffer
* @throws IndexOutOfBoundsException if offset, start,
* or end are out of bounds
* @since 1.5
*/
public synchronized StringBuffer insert(int offset, CharSequence sequence,
int start, int end)
{
if (sequence == null)
sequence = "null";
if (start < 0 || end < 0 || start > end || end > sequence.length())
throw new IndexOutOfBoundsException();
int len = end - start;
ensureCapacity_unsynchronized(count + len);
System.arraycopy(value, offset, value, offset + len, count - offset);
for (int i = start; i < end; ++i)
value[offset++] = sequence.charAt(i);
count += len;
return this;
}
/**
* Insert the char[] argument into this
* StringBuffer.
*
* @param offset the place to insert in this buffer
* @param data the char[] to insert
* @return this StringBuffer
* @throws NullPointerException if data is null
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see #insert(int, char[], int, int)
*/
public StringBuffer insert(int offset, char[] data)
{
return insert(offset, data, 0, data.length);
}
/**
* Insert the String value of the argument into this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param offset the place to insert in this buffer
* @param bool the boolean to convert and insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(boolean)
*/
public StringBuffer insert(int offset, boolean bool)
{
return insert(offset, bool ? "true" : "false");
}
/**
* Insert the char argument into this StringBuffer.
*
* @param offset the place to insert in this buffer
* @param ch the char to insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if offset is out of bounds
*/
public synchronized StringBuffer insert(int offset, char ch)
{
if (offset < 0 || offset > count)
throw new StringIndexOutOfBoundsException(offset);
ensureCapacity_unsynchronized(count + 1);
System.arraycopy(value, offset, value, offset + 1, count - offset);
value[offset] = ch;
count++;
return this;
}
/**
* Insert the String value of the argument into this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param offset the place to insert in this buffer
* @param inum the int to convert and insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(int)
*/
public StringBuffer insert(int offset, int inum)
{
return insert(offset, String.valueOf(inum));
}
/**
* Insert the String value of the argument into this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param offset the place to insert in this buffer
* @param lnum the long to convert and insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(long)
*/
public StringBuffer insert(int offset, long lnum)
{
return insert(offset, Long.toString(lnum, 10));
}
/**
* Insert the String value of the argument into this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param offset the place to insert in this buffer
* @param fnum the float to convert and insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(float)
*/
public StringBuffer insert(int offset, float fnum)
{
return insert(offset, Float.toString(fnum));
}
/**
* Insert the String value of the argument into this
* StringBuffer. Uses String.valueOf() to convert
* to String.
*
* @param offset the place to insert in this buffer
* @param dnum the double to convert and insert
* @return this StringBuffer
* @throws StringIndexOutOfBoundsException if offset is out of bounds
* @see String#valueOf(double)
*/
public StringBuffer insert(int offset, double dnum)
{
return insert(offset, Double.toString(dnum));
}
/**
* Finds the first instance of a substring in this StringBuffer.
*
* @param str String to find
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @see #indexOf(String, int)
* @since 1.4
*/
public int indexOf(String str)
{
return indexOf(str, 0);
}
/**
* Finds the first instance of a String in this StringBuffer, starting at
* a given index. If starting index is less than 0, the search starts at
* the beginning of this String. If the starting index is greater than the
* length of this String, or the substring is not found, -1 is returned.
*
* @param str String to find
* @param fromIndex index to start the search
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @since 1.4
*/
public synchronized int indexOf(String str, int fromIndex)
{
if (fromIndex < 0)
fromIndex = 0;
int limit = count - str.count;
for ( ; fromIndex <= limit; fromIndex++)
if (regionMatches(fromIndex, str))
return fromIndex;
return -1;
}
/**
* Finds the last instance of a substring in this StringBuffer.
*
* @param str String to find
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @see #lastIndexOf(String, int)
* @since 1.4
*/
public int lastIndexOf(String str)
{
return lastIndexOf(str, count - str.count);
}
/**
* Finds the last instance of a String in this StringBuffer, starting at a
* given index. If starting index is greater than the maximum valid index,
* then the search begins at the end of this String. If the starting index
* is less than zero, or the substring is not found, -1 is returned.
*
* @param str String to find
* @param fromIndex index to start the search
* @return location (base 0) of the String, or -1 if not found
* @throws NullPointerException if str is null
* @since 1.4
*/
public synchronized int lastIndexOf(String str, int fromIndex)
{
fromIndex = Math.min(fromIndex, count - str.count);
for ( ; fromIndex >= 0; fromIndex--)
if (regionMatches(fromIndex, str))
return fromIndex;
return -1;
}
/**
* Reverse the characters in this StringBuffer. The same sequence of
* characters exists, but in the reverse index ordering.
*
* @return this StringBuffer
*/
public synchronized StringBuffer reverse()
{
// Call ensureCapacity to enforce copy-on-write.
ensureCapacity_unsynchronized(count);
for (int i = count >> 1, j = count - i; --i >= 0; ++j)
{
char c = value[i];
value[i] = value[j];
value[j] = c;
}
return this;
}
/**
* Convert this StringBuffer to a String. The
* String is composed of the characters currently in this StringBuffer. Note
* that the result is a copy, and that future modifications to this buffer
* do not affect the String.
*
* @return the characters in this StringBuffer
*/
public String toString()
{
// The string will set this.shared = true.
return new String(this);
}
/**
* This may reduce the amount of memory used by the StringBuffer,
* by resizing the internal array to remove unused space. However,
* this method is not required to resize, so this behavior cannot
* be relied upon.
* @since 1.5
*/
public synchronized void trimToSize()
{
int wouldSave = value.length - count;
// Some random heuristics: if we save less than 20 characters, who
// cares.
if (wouldSave < 20)
return;
// If we save more than 200 characters, shrink.
// If we save more than 1/4 of the buffer, shrink.
if (wouldSave > 200 || wouldSave * 4 > value.length)
{
char[] newValue = new char[count];
System.arraycopy(value, 0, newValue, 0, count);
value = newValue;
}
}
/**
* Return the number of code points between two indices in the
* StringBuffer. An unpaired surrogate counts as a
* code point for this purpose. Characters outside the indicated
* range are not examined, even if the range ends in the middle of a
* surrogate pair.
*
* @param start the starting index
* @param end one past the ending index
* @return the number of code points
* @since 1.5
*/
public synchronized int codePointCount(int start, int end)
{
if (start < 0 || end >= count || start > end)
throw new StringIndexOutOfBoundsException();
int count = 0;
while (start < end)
{
char base = value[start];
if (base < Character.MIN_HIGH_SURROGATE
|| base > Character.MAX_HIGH_SURROGATE
|| start == end
|| start == count
|| value[start + 1] < Character.MIN_LOW_SURROGATE
|| value[start + 1] > Character.MAX_LOW_SURROGATE)
{
// Nothing.
}
else
{
// Surrogate pair.
++start;
}
++start;
++count;
}
return count;
}
/**
* Starting at the given index, this counts forward by the indicated
* number of code points, and then returns the resulting index. An
* unpaired surrogate counts as a single code point for this
* purpose.
*
* @param start the starting index
* @param codePoints the number of code points
* @return the resulting index
* @since 1.5
*/
public synchronized int offsetByCodePoints(int start, int codePoints)
{
while (codePoints > 0)
{
char base = value[start];
if (base < Character.MIN_HIGH_SURROGATE
|| base > Character.MAX_HIGH_SURROGATE
|| start == count
|| value[start + 1] < Character.MIN_LOW_SURROGATE
|| value[start + 1] > Character.MAX_LOW_SURROGATE)
{
// Nothing.
}
else
{
// Surrogate pair.
++start;
}
++start;
--codePoints;
}
return start;
}
/**
* An unsynchronized version of ensureCapacity, used internally to avoid
* the cost of a second lock on the same object. This also has the side
* effect of duplicating the array, if it was shared (to form copy-on-write
* semantics).
*
* @param minimumCapacity the minimum capacity
* @see #ensureCapacity(int)
*/
private void ensureCapacity_unsynchronized(int minimumCapacity)
{
if (shared || minimumCapacity > value.length)
{
// We don't want to make a larger vector when `shared' is
// set. If we do, then setLength becomes very inefficient
// when repeatedly reusing a StringBuffer in a loop.
int max = (minimumCapacity > value.length
? value.length * 2 + 2
: value.length);
minimumCapacity = (minimumCapacity < max ? max : minimumCapacity);
char[] nb = new char[minimumCapacity];
System.arraycopy(value, 0, nb, 0, count);
value = nb;
shared = false;
}
}
/**
* Predicate which determines if a substring of this matches another String
* starting at a specified offset for each String and continuing for a
* specified length. This is more efficient than creating a String to call
* indexOf on.
*
* @param toffset index to start comparison at for this String
* @param other non-null String to compare to region of this
* @return true if regions match, false otherwise
* @see #indexOf(String, int)
* @see #lastIndexOf(String, int)
* @see String#regionMatches(boolean, int, String, int, int)
*/
// GCJ LOCAL: native for gcj.
private native boolean regionMatches(int toffset, String other);
}