java.lang.StringBuffer Maven / Gradle / Ivy
/*
This is not an official specification document, and usage is restricted.
NOTICE
(c) 2005-2007 Sun Microsystems, Inc. All Rights Reserved.
Neither this file nor any files generated from it describe a complete
specification, and they may only be used as described below. For
example, no permission is given for you to incorporate this file, in
whole or in part, in an implementation of a Java specification.
Sun Microsystems Inc. owns the copyright in this file and it is provided
to you for informative, as opposed to normative, use. The file and any
files generated from it may be used to generate other informative
documentation, such as a unified set of documents of API signatures for
a platform that includes technologies expressed as Java APIs. The file
may also be used to produce "compilation stubs," which allow
applications to be compiled and validated for such platforms.
Any work generated from this file, such as unified javadocs or compiled
stub files, must be accompanied by this notice in its entirety.
This work corresponds to the API signatures of JSR 219: Foundation
Profile 1.1. In the event of a discrepency between this work and the
JSR 219 specification, which is available at
http://www.jcp.org/en/jsr/detail?id=219, the latter takes precedence.
*/
package java.lang;
/**
* A string buffer implements a mutable sequence of characters.
* A string buffer is like a {@link 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.
*
* String buffers are used by the compiler to implement the binary
* string concatenation operator +. For example, the code:
*
* x = "a" + 4 + "c"
*
* is compiled to the equivalent of:
*
* x = new StringBuffer().append("a").append(4).append("c")
* .toString()
*
* which creates a new string buffer (initially empty), appends the string
* representation of each operand to the string buffer in turn, and then
* converts the contents of the string buffer to a string. Overall, this avoids
* creating many temporary strings.
*
* 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).
*
* 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.
*
* @author Arthur van Hoff
* @version 1.78, 05/16/03
* @see java.io.ByteArrayOutputStream
* @see java.lang.String
* @since JDK1.0
*/
public final class StringBuffer
implements java.io.Serializable, java.lang.CharSequence
{
/**
* The value is used for character storage.
*
* @serial
*/
private char[] value;
/**
* The count is the number of characters in the buffer.
*
* @serial
*/
private int count;
/**
* A flag indicating whether the buffer is shared
*
* @serial
*/
private boolean shared;
/** use serialVersionUID from JDK 1.0.2 for interoperability */
static final long serialVersionUID = 3388685877147921107L;
/**
* Constructs a string buffer with no characters in it and an
* initial capacity of 16 characters.
*/
public StringBuffer() { }
/**
* Constructs a string buffer with no characters in it and an
* initial capacity specified by the length argument.
*
* @param length the initial capacity.
* @exception NegativeArraySizeException if the length
* argument is less than 0.
*/
public StringBuffer(int length) { }
/**
* Constructs a string buffer so that it represents the same
* sequence of characters as the string argument; in other
* words, the initial contents of the string buffer is a copy of the
* argument string. The initial capacity of the string buffer is
* 16 plus the length of the string argument.
*
* @param str the initial contents of the buffer.
* @exception NullPointerException if str is null
*/
public StringBuffer(java.lang.String str) { }
/**
* Returns the length (character count) of this string buffer.
*
* @return the length of the sequence of characters currently
* represented by this string buffer.
*/
public synchronized int length() {
return 0;
}
/**
* Returns the current capacity of the String buffer. The capacity
* is the amount of storage available for newly inserted
* characters; beyond which an allocation will occur.
*
* @return the current capacity of this string buffer.
*/
public synchronized int capacity() {
return 0;
}
/**
* Ensures that the capacity of the buffer is at least equal to the
* specified minimum.
* If the current capacity of this string buffer is less than the
* argument, then a new internal buffer is allocated with greater
* capacity. The new capacity is the larger of:
*
* - The
minimumCapacity argument.
* - Twice the old capacity, plus
2.
*
* If the minimumCapacity argument is nonpositive, this
* method takes no action and simply returns.
*
* @param minimumCapacity the minimum desired capacity.
*/
public synchronized void ensureCapacity(int minimumCapacity) { }
/**
* Sets the length of this String buffer.
* This string buffer is altered to represent a new character sequence
* whose length is specified by the argument. For every nonnegative
* index k less than 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 of the string buffer, the string buffer is
* truncated to contain exactly the number of characters given by the
* newLength argument.
*
* If the newLength argument is greater than or equal
* to the current length, sufficient null characters
* ('\u0000') are appended to the string buffer so that
* length becomes the newLength argument.
*
* The newLength argument must be greater than or equal
* to 0.
*
* @param newLength the new length of the buffer.
* @exception IndexOutOfBoundsException if the
* newLength argument is negative.
* @see java.lang.StringBuffer#length()
*/
public synchronized void setLength(int newLength) { }
/**
* The specified character of the sequence currently represented by
* the string buffer, as indicated by the index argument,
* is returned. The first character of a string buffer is at index
* 0, the next at index 1, and so on, for
* array indexing.
*
* The index argument must be greater than or equal to
* 0, and less than the length of this string buffer.
*
* @param index the index of the desired character.
* @return the character at the specified index of this string buffer.
* @exception IndexOutOfBoundsException if index is
* negative or greater than or equal to length().
* @see java.lang.StringBuffer#length()
*/
public synchronized char charAt(int index) {
return ' ';
}
/**
* Characters are copied from this string buffer into the
* destination character array 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
*
*
* @param srcBegin start copying at this offset in the string buffer.
* @param srcEnd stop copying at this offset in the string buffer.
* @param dst the array to copy the data into.
* @param dstBegin offset into dst.
* @exception NullPointerException if dst is
* null.
* @exception IndexOutOfBoundsException if any of the following is true:
*
* srcBegin is negative
* dstBegin is negative
* - the
srcBegin argument is greater than
* the srcEnd argument.
* srcEnd is greater than
* this.length(), the current length of this
* string buffer.
* dstBegin+srcEnd-srcBegin is greater than
* dst.length
*
*/
public synchronized void getChars(int srcBegin, int srcEnd, char[] dst, int
dstBegin)
{ }
/**
* The character at the specified index of this string buffer is set
* to ch. The string buffer 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 string buffer.
*
* @param index the index of the character to modify.
* @param ch the new character.
* @exception IndexOutOfBoundsException if index is
* negative or greater than or equal to length().
* @see java.lang.StringBuffer#length()
*/
public synchronized void setCharAt(int index, char ch) { }
/**
* Appends the string representation of the Object
* argument to this string buffer.
*
* The argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then appended to this string buffer.
*
* @param obj an Object.
* @return a reference to this StringBuffer object.
* @see java.lang.String#valueOf(java.lang.Object)
* @see java.lang.StringBuffer#append(java.lang.String)
*/
public synchronized java.lang.StringBuffer append(java.lang.Object obj) {
return null;
}
/**
* Appends the string to this string buffer.
*
* The characters of the String argument are appended, in
* order, to the contents of this string buffer, increasing the
* length of this string buffer by the length of the argument.
* If str is null, then the four characters
* "null" are appended to this string buffer.
*
* Let n be the length of the old character sequence, the one
* contained in the string buffer 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.
*
* @param str a string.
* @return a reference to this StringBuffer.
*/
public synchronized java.lang.StringBuffer append(java.lang.String str) {
return null;
}
/**
* Appends the specified StringBuffer to this
* StringBuffer.
*
* 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.
*
* The method ensureCapacity is first called on this
* StringBuffer with the new buffer length as its argument.
* (This ensures that the storage of this StringBuffer is
* adequate to contain the additional characters being appended.)
*
* @param sb the StringBuffer to append.
* @return a reference to this StringBuffer.
* @since 1.4
*/
public synchronized java.lang.StringBuffer append(java.lang.StringBuffer sb)
{
return null;
}
/**
* Appends the string representation of the char array
* argument to this string buffer.
*
* The characters of the array argument are appended, in order, to
* the contents of this string buffer. The length of this string
* buffer increases by the length of the argument.
*
* The overall effect is exactly as if the argument were converted to
* a string by the method {@link String#valueOf(char[])} and the
* characters of that string were then {@link #append(String) appended}
* to this StringBuffer object.
*
* @param str the characters to be appended.
* @return a reference to this StringBuffer object.
*/
public synchronized java.lang.StringBuffer append(char[] str) {
return null;
}
/**
* Appends the string representation of a subarray of the
* char array argument to this string buffer.
*
* Characters of the character array str, starting at
* index offset, are appended, in order, to the contents
* of this string buffer. The length of this string buffer increases
* by the value of len.
*
* The overall effect is exactly as if the arguments were converted to
* a string by the method {@link String#valueOf(char[],int,int)} and the
* characters of that string were then {@link #append(String) appended}
* to this StringBuffer object.
*
* @param str the characters to be appended.
* @param offset the index of the first character to append.
* @param len the number of characters to append.
* @return a reference to this StringBuffer object.
*/
public synchronized java.lang.StringBuffer append(char[] str, int
offset, int len)
{
return null;
}
/**
* Appends the string representation of the boolean
* argument to the string buffer.
*
* The argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then appended to this string buffer.
*
* @param b a boolean.
* @return a reference to this StringBuffer.
* @see java.lang.String#valueOf(boolean)
* @see java.lang.StringBuffer#append(java.lang.String)
*/
public java.lang.StringBuffer append(boolean b) {
return null;
}
/**
* Appends the string representation of the char
* argument to this string buffer.
*
* The argument is appended to the contents of this string buffer.
* The length of this string buffer increases by 1.
*
* The overall effect is exactly as if the argument were converted to
* a string by the method {@link String#valueOf(char)} and the character
* in that string were then {@link #append(String) appended} to this
* StringBuffer object.
*
* @param c a char.
* @return a reference to this StringBuffer object.
*/
public synchronized java.lang.StringBuffer append(char c) {
return null;
}
/**
* Appends the string representation of the int
* argument to this string buffer.
*
* The argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then appended to this string buffer.
*
* @param i an int.
* @return a reference to this StringBuffer object.
* @see java.lang.String#valueOf(int)
* @see java.lang.StringBuffer#append(java.lang.String)
*/
public synchronized java.lang.StringBuffer append(int i) {
return null;
}
/**
* Appends the string representation of the long
* argument to this string buffer.
*
* The argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then appended to this string buffer.
*
* @param l a long.
* @return a reference to this StringBuffer object.
* @see java.lang.String#valueOf(long)
* @see java.lang.StringBuffer#append(java.lang.String)
*/
public synchronized java.lang.StringBuffer append(long l) {
return null;
}
/**
* Appends the string representation of the float
* argument to this string buffer.
*
* The argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then appended to this string buffer.
*
* @param f a float.
* @return a reference to this StringBuffer object.
* @see java.lang.String#valueOf(float)
* @see java.lang.StringBuffer#append(java.lang.String)
*/
public synchronized java.lang.StringBuffer append(float f) {
return null;
}
/**
* Appends the string representation of the double
* argument to this string buffer.
*
* The argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then appended to this string buffer.
*
* @param d a double.
* @return a reference to this StringBuffer object.
* @see java.lang.String#valueOf(double)
* @see java.lang.StringBuffer#append(java.lang.String)
*/
public synchronized java.lang.StringBuffer append(double d) {
return null;
}
/**
* Removes the characters in a substring of this StringBuffer.
* The substring begins at the specified start and extends to
* the character at index end - 1 or to the end of the
* StringBuffer if no such character exists. If
* start is equal to end, no changes are made.
*
* @param start The beginning index, inclusive.
* @param end The ending index, exclusive.
* @return This string buffer.
* @exception StringIndexOutOfBoundsException if start
* is negative, greater than length(), or
* greater than end.
* @since 1.2
*/
public synchronized java.lang.StringBuffer delete(int start, int end) {
return null;
}
/**
* Removes the character at the specified position in this
* StringBuffer (shortening the StringBuffer
* by one character).
*
* @param index Index of character to remove
* @return This string buffer.
* @exception StringIndexOutOfBoundsException if the index
* is negative or greater than or equal to
* length().
* @since 1.2
*/
public synchronized java.lang.StringBuffer deleteCharAt(int index) {
return null;
}
/**
* Replaces the characters in a substring of this StringBuffer
* with characters in the specified String. The substring
* begins at the specified start and extends to the character
* at index end - 1 or to the end of the
* StringBuffer if no such character exists. First the
* characters in the substring are removed and then the specified
* String is inserted at start. (The
* StringBuffer will be lengthened to accommodate the
* specified String if necessary.)
*
* @param start The beginning index, inclusive.
* @param end The ending index, exclusive.
* @param str String that will replace previous contents.
* @return This string buffer.
* @exception StringIndexOutOfBoundsException if start
* is negative, greater than length(), or
* greater than end.
* @since 1.2
*/
public synchronized java.lang.StringBuffer replace(int start, int end,
java.lang.String str)
{
return null;
}
/**
* Returns a new String that contains a subsequence of
* characters currently contained in this StringBuffer.The
* substring begins at the specified index and extends to the end of the
* StringBuffer.
*
* @param start The beginning index, inclusive.
* @return The new string.
* @exception StringIndexOutOfBoundsException if start is
* less than zero, or greater than the length of this
* StringBuffer.
* @since 1.2
*/
public synchronized java.lang.String substring(int start) {
return null;
}
/**
* Returns a new character sequence that is a subsequence of this sequence.
*
*
An invocation of this method of the form
*
*
* sb.subSequence(begin, end)
*
* behaves in exactly the same way as the invocation
*
*
* sb.substring(begin, end)
*
* This method is provided so that the StringBuffer class can
* implement the {@link CharSequence} interface.
*
* @param start the start index, inclusive.
* @param end the end index, exclusive.
* @return the specified subsequence.
*
* @throws IndexOutOfBoundsException
* if start or end are negative,
* if end is greater than length(),
* or if start is greater than end
*
* @since 1.4
* @spec JSR-51
*/
public java.lang.CharSequence subSequence(int start, int end) {
return null;
}
/**
* Returns a new String that contains a subsequence of
* characters currently contained in this StringBuffer. The
* substring begins at the specified start and
* extends to the character at index end - 1. An
* exception is thrown if
*
* @param start The beginning index, inclusive.
* @param end The ending index, exclusive.
* @return The new string.
* @exception StringIndexOutOfBoundsException if start
* or end are negative or greater than
* length(), or start is
* greater than end.
* @since 1.2
*/
public synchronized java.lang.String substring(int start, int end) {
return null;
}
/**
* Inserts the string representation of a subarray of the str
* array argument into this string buffer. The subarray begins at the
* specified offset and extends len characters.
* The characters of the subarray are inserted into this string buffer at
* the position indicated by index. The length of this
* StringBuffer increases by len characters.
*
* @param index position at which to insert subarray.
* @param str A character array.
* @param offset the index of the first character in subarray to
* to be inserted.
* @param len the number of characters in the subarray to
* to be inserted.
* @return This string buffer.
* @exception StringIndexOutOfBoundsException if index
* is negative or greater than length(), or
* offset or len are negative, or
* (offset+len) is greater than
* str.length.
* @since 1.2
*/
public synchronized java.lang.StringBuffer insert(int index, char[] str, int
offset, int len)
{
return null;
}
/**
* Inserts the string representation of the Object
* argument into this string buffer.
*
* The second argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then inserted into this string buffer 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
* string buffer.
*
* @param offset the offset.
* @param obj an Object.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
* @see java.lang.String#valueOf(java.lang.Object)
* @see java.lang.StringBuffer#insert(int, java.lang.String)
* @see java.lang.StringBuffer#length()
*/
public synchronized java.lang.StringBuffer insert(int offset,
java.lang.Object obj)
{
return null;
}
/**
* Inserts the string into this string buffer.
*
* The characters of the String argument are inserted, in
* order, into this string buffer at the indicated offset, moving up any
* characters originally above that position and increasing the length
* of this string buffer by the length of the argument. If
* str is null, then the four characters
* "null" are inserted into this string buffer.
*
* 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
offset
* - the character at index k
-offset in the
* argument str, if k is not less than
* offset but is less than offset+str.length()
* - the character at index k
-str.length() in the
* old character sequence, if k is not less than
* offset+str.length()
*
* The offset argument must be greater than or equal to
* 0, and less than or equal to the length of this
* string buffer.
*
* @param offset the offset.
* @param str a string.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
* @see java.lang.StringBuffer#length()
*/
public synchronized java.lang.StringBuffer insert(int offset,
java.lang.String str)
{
return null;
}
/**
* Inserts the string representation of the char array
* argument into this string buffer.
*
* The characters of the array argument are inserted into the
* contents of this string buffer at the position indicated by
* offset. The length of this string buffer increases by
* the length of the argument.
*
* The overall effect is exactly as if the argument were converted to
* a string by the method {@link String#valueOf(char[])} and the
* characters of that string were then
* {@link #insert(int,String) inserted} into this
* StringBuffer object at the position indicated by
* offset.
*
* @param offset the offset.
* @param str a character array.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
*/
public synchronized java.lang.StringBuffer insert(int offset, char[] str) {
return null;
}
/**
* Inserts the string representation of the boolean
* argument into this string buffer.
*
* The second argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then inserted into this string buffer 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
* string buffer.
*
* @param offset the offset.
* @param b a boolean.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
* @see java.lang.String#valueOf(boolean)
* @see java.lang.StringBuffer#insert(int, java.lang.String)
* @see java.lang.StringBuffer#length()
*/
public java.lang.StringBuffer insert(int offset, boolean b) {
return null;
}
/**
* Inserts the string representation of the char
* argument into this string buffer.
*
* The second argument is inserted into the contents of this string
* buffer at the position indicated by offset. The length
* of this string buffer increases by one.
*
* The overall effect is exactly as if the argument were converted to
* a string by the method {@link String#valueOf(char)} and the character
* in that string were then {@link #insert(int, String) inserted} into
* this StringBuffer object at the position indicated by
* offset.
*
* The offset argument must be greater than or equal to
* 0, and less than or equal to the length of this
* string buffer.
*
* @param offset the offset.
* @param c a char.
* @return a reference to this StringBuffer object.
* @exception IndexOutOfBoundsException if the offset is invalid.
* @see java.lang.StringBuffer#length()
*/
public synchronized java.lang.StringBuffer insert(int offset, char c) {
return null;
}
/**
* Inserts the string representation of the second int
* argument into this string buffer.
*
* The second argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then inserted into this string buffer 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
* string buffer.
*
* @param offset the offset.
* @param i an int.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
* @see java.lang.String#valueOf(int)
* @see java.lang.StringBuffer#insert(int, java.lang.String)
* @see java.lang.StringBuffer#length()
*/
public java.lang.StringBuffer insert(int offset, int i) {
return null;
}
/**
* Inserts the string representation of the long
* argument into this string buffer.
*
* The second argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then inserted into this string buffer at the position
* indicated by offset.
*
* The offset argument must be greater than or equal to
* 0, and less than or equal to the length of this
* string buffer.
*
* @param offset the offset.
* @param l a long.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
* @see java.lang.String#valueOf(long)
* @see java.lang.StringBuffer#insert(int, java.lang.String)
* @see java.lang.StringBuffer#length()
*/
public java.lang.StringBuffer insert(int offset, long l) {
return null;
}
/**
* Inserts the string representation of the float
* argument into this string buffer.
*
* The second argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then inserted into this string buffer 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
* string buffer.
*
* @param offset the offset.
* @param f a float.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
* @see java.lang.String#valueOf(float)
* @see java.lang.StringBuffer#insert(int, java.lang.String)
* @see java.lang.StringBuffer#length()
*/
public java.lang.StringBuffer insert(int offset, float f) {
return null;
}
/**
* Inserts the string representation of the double
* argument into this string buffer.
*
* The second argument is converted to a string as if by the method
* String.valueOf, and the characters of that
* string are then inserted into this string buffer 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
* string buffer.
*
* @param offset the offset.
* @param d a double.
* @return a reference to this StringBuffer object.
* @exception StringIndexOutOfBoundsException if the offset is invalid.
* @see java.lang.String#valueOf(double)
* @see java.lang.StringBuffer#insert(int, java.lang.String)
* @see java.lang.StringBuffer#length()
*/
public java.lang.StringBuffer insert(int offset, double d) {
return null;
}
/**
* Returns the index within this string of the first occurrence of the
* specified substring. The integer returned is the smallest value
* k such that:
*
* this.toString().startsWith(str, k)
*
* is true.
*
* @param str any string.
* @return if the string argument occurs as a substring within this
* object, then the index of the first character of the first
* such substring is returned; if it does not occur as a
* substring, -1 is returned.
* @exception java.lang.NullPointerException if str is
* null.
* @since 1.4
*/
public int indexOf(java.lang.String str) {
return 0;
}
/**
* Returns the index within this string of the first occurrence of the
* specified substring, starting at the specified index. The integer
* returned is the smallest value k for which:
*
* k >= Math.min(fromIndex, str.length()) &&
* this.toString().startsWith(str, k)
*
* If no such value of k exists, then -1 is returned.
*
* @param str the substring for which to search.
* @param fromIndex the index from which to start the search.
* @return the index within this string of the first occurrence of the
* specified substring, starting at the specified index.
* @exception java.lang.NullPointerException if str is
* null.
* @since 1.4
*/
public synchronized int indexOf(java.lang.String str, int fromIndex) {
return 0;
}
/**
* Returns the index within this string of the rightmost occurrence
* of the specified substring. The rightmost empty string "" is
* considered to occur at the index value this.length().
* The returned index is the largest value k such that
*
* this.toString().startsWith(str, k)
*
* is true.
*
* @param str the substring to search for.
* @return if the string argument occurs one or more times as a substring
* within this object, then the index of the first character of
* the last such substring is returned. If it does not occur as
* a substring, -1 is returned.
* @exception java.lang.NullPointerException if str is
* null.
* @since 1.4
*/
public synchronized int lastIndexOf(java.lang.String str) {
return 0;
}
/**
* Returns the index within this string of the last occurrence of the
* specified substring. The integer returned is the largest value k
* such that:
*
* k <= Math.min(fromIndex, str.length()) &&
* this.toString().startsWith(str, k)
*
* If no such value of k exists, then -1 is returned.
*
* @param str the substring to search for.
* @param fromIndex the index to start the search from.
* @return the index within this string of the last occurrence of the
* specified substring.
* @exception java.lang.NullPointerException if str is
* null.
* @since 1.4
*/
public synchronized int lastIndexOf(java.lang.String str, int fromIndex) {
return 0;
}
/**
* The character sequence contained in this string buffer is
* replaced by the reverse of the sequence.
*
* Let n be the length of the old character sequence, the one
* contained in the string buffer 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.
*
* @return a reference to this StringBuffer object.
* @since JDK1.0.2
*/
public synchronized java.lang.StringBuffer reverse() {
return null;
}
/**
* Converts to a string representing the data in this string buffer.
* A new String object is allocated and initialized to
* contain the character sequence currently represented by this
* string buffer. This String is then returned. Subsequent
* changes to the string buffer do not affect the contents of the
* String.
*
* Implementation advice: This method can be coded so as to create a new
* String object without allocating new memory to hold a
* copy of the character sequence. Instead, the string can share the
* memory used by the string buffer. Any subsequent operation that alters
* the content or capacity of the string buffer must then make a copy of
* the internal buffer at that time. This strategy is effective for
* reducing the amount of memory allocated by a string concatenation
* operation when it is implemented using a string buffer.
*
* @return a string representation of the string buffer.
*/
public java.lang.String toString() {
return null;
}
/**
* readObject is called to restore the state of the StringBuffer from
* a stream.
*/
private synchronized void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, java.lang.ClassNotFoundException
{ }
}