StringBuilder (Java SE 10 & JDK 10 ) (original) (raw)

Constructor Summary

Constructors

Constructor	Description
StringBuilder()	Constructs a string builder with no characters in it and an initial capacity of 16 characters.
StringBuilder(int capacity)	Constructs a string builder with no characters in it and an initial capacity specified by the capacity argument.
StringBuilder(CharSequence seq)	Constructs a string builder that contains the same characters as the specified CharSequence.
StringBuilder(String str)	Constructs a string builder initialized to the contents of the specified string.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods

Modifier and Type	Method	Description
java.lang.AbstractStringBuilder	append(boolean b)	Appends the string representation of the boolean argument to the sequence.
java.lang.AbstractStringBuilder	append(char c)	Appends the string representation of the char argument to this sequence.
java.lang.AbstractStringBuilder	append(char[] str)	Appends the string representation of the char array argument to this sequence.
java.lang.AbstractStringBuilder	append(double d)	Appends the string representation of the double argument to this sequence.
java.lang.AbstractStringBuilder	append(float f)	Appends the string representation of the float argument to this sequence.
java.lang.AbstractStringBuilder	append(int i)	Appends the string representation of the int argument to this sequence.
java.lang.AbstractStringBuilder	append(long l)	Appends the string representation of the long argument to this sequence.
java.lang.AbstractStringBuilder	append(CharSequence s)	Appends the specified character sequence to this Appendable.
java.lang.AbstractStringBuilder	append(Object obj)	Appends the string representation of the Object argument.
java.lang.AbstractStringBuilder	append(String str)	Appends the specified string to this character sequence.
StringBuilder	append(char[] str, int offset, int len)	Appends the string representation of a subarray of thechar array argument to this sequence.
StringBuilder	append(CharSequence s, int start, int end)	Appends a subsequence of the specified CharSequence to this sequence.
StringBuilder	append(StringBuffer sb)	Appends the specified StringBuffer to this sequence.
StringBuilder	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.
IntStream	chars()	Returns a stream of int zero-extending the char values from this sequence.
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.
IntStream	codePoints()	Returns a stream of code point values from this sequence.
StringBuilder	delete(int start, int end)	Removes the characters in a substring of this sequence.
StringBuilder	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.
StringBuilder	insert(int offset, boolean b)	Inserts the string representation of the boolean argument into this sequence.
StringBuilder	insert(int offset, char c)	Inserts the string representation of the char argument into this sequence.
StringBuilder	insert(int offset, char[] str)	Inserts the string representation of the char array argument into this sequence.
StringBuilder	insert(int index, char[] str, int offset, int len)	Inserts the string representation of a subarray of the str array argument into this sequence.
StringBuilder	insert(int offset, double d)	Inserts the string representation of the double argument into this sequence.
StringBuilder	insert(int offset, float f)	Inserts the string representation of the float argument into this sequence.
StringBuilder	insert(int offset, int i)	Inserts the string representation of the second int argument into this sequence.
StringBuilder	insert(int offset, long l)	Inserts the string representation of the long argument into this sequence.
StringBuilder	insert(int dstOffset,CharSequence s)	Inserts the specified CharSequence into this sequence.
StringBuilder	insert(int dstOffset,CharSequence s, int start, int end)	Inserts a subsequence of the specified CharSequence into this sequence.
StringBuilder	insert(int offset,Object obj)	Inserts the string representation of the Object argument into this character sequence.
StringBuilder	insert(int offset,String str)	Inserts the string into this character sequence.
int	lastIndexOf(String str)	Returns the index within this string of the last 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, searching backward starting at the specified index.
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 by codePointOffset code points.
StringBuilder	replace(int start, int end,String str)	Replaces the characters in a substring of this sequence with characters in the specified String.
java.lang.AbstractStringBuilder	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.
abstract String	toString()	Returns a string representing the data in this sequence.
void	trimToSize()	Attempts to reduce storage used for the character sequence.

   * ### Methods declared in interface java.lang.[CharSequence](../../java/lang/CharSequence.html "interface in java.lang")  
   `[charAt](../../java/lang/CharSequence.html#charAt%28int%29), [chars](../../java/lang/CharSequence.html#chars%28%29), [codePoints](../../java/lang/CharSequence.html#codePoints%28%29), [length](../../java/lang/CharSequence.html#length%28%29), [subSequence](../../java/lang/CharSequence.html#subSequence%28int,int%29), [toString](../../java/lang/CharSequence.html#toString%28%29)`  
   * ### Methods declared in class java.lang.[Object](../../java/lang/Object.html "class in java.lang")  
   `[clone](../../java/lang/Object.html#clone%28%29), [equals](../../java/lang/Object.html#equals%28java.lang.Object%29), [finalize](../../java/lang/Object.html#finalize%28%29), [getClass](../../java/lang/Object.html#getClass%28%29), [hashCode](../../java/lang/Object.html#hashCode%28%29), [notify](../../java/lang/Object.html#notify%28%29), [notifyAll](../../java/lang/Object.html#notifyAll%28%29), [wait](../../java/lang/Object.html#wait%28%29), [wait](../../java/lang/Object.html#wait%28long%29), [wait](../../java/lang/Object.html#wait%28long,int%29)`

Constructor Detail

 * #### StringBuilder  
 public StringBuilder()  
 Constructs a string builder with no characters in it and an initial capacity of 16 characters.  
 * #### StringBuilder  
 public StringBuilder(int capacity)  
 Constructs a string builder with no characters in it and an initial capacity specified by the `capacity` argument.  
 Parameters:  
 `capacity` \- the initial capacity.  
 Throws:  
 `[NegativeArraySizeException](../../java/lang/NegativeArraySizeException.html "class in java.lang")` \- if the `capacity` argument is less than `0`.  
 * #### StringBuilder  
 public StringBuilder([String](../../java/lang/String.html "class in java.lang") str)  
 Constructs a string builder initialized to the contents of the specified string. The initial capacity of the string builder is`16` plus the length of the string argument.  
 Parameters:  
 `str` \- the initial contents of the buffer.  
 * #### StringBuilder  
 public StringBuilder([CharSequence](../../java/lang/CharSequence.html "interface in java.lang") seq)  
 Constructs a string builder that contains the same characters as the specified `CharSequence`. The initial capacity of the string builder is `16` plus the length of the`CharSequence` argument.  
 Parameters:  
 `seq` \- the sequence to copy.

Method Detail

* #### append  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") append([StringBuffer](../../java/lang/StringBuffer.html "class in java.lang") sb)  
Appends the specified `StringBuffer` to this sequence.  
 The characters of the `StringBuffer` argument are appended, in order, to this sequence, increasing the length of this sequence by the length of the argument. If `sb` is `null`, then the four characters`"null"` are appended to this sequence.  
 Let _n_ be the length of this character sequence just prior to execution of the `append` method. Then the character at index_k_ in the new character sequence is equal to the character at index _k_ in the old character sequence, if _k_ is less than_n_; otherwise, it is equal to the character at index _k-n_ in the argument `sb`.  
Parameters:  
`sb` \- the `StringBuffer` to append.  
Returns:  
a reference to this object.  
* #### append  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") append([CharSequence](../../java/lang/CharSequence.html "interface in java.lang") s,  
                            int start,  
                            int end)  
Appends a subsequence of the specified `CharSequence` to this sequence.  
 Characters of the argument `s`, starting at index `start`, are appended, in order, to the contents of this sequence up to the (exclusive) index `end`. The length of this sequence is increased by the value of `end - start`.  
 Let _n_ be the length of this character sequence just prior to execution of the `append` method. Then the character at index _k_ in this character sequence becomes equal to the character at index _k_ in this sequence, if _k_ is less than_n_; otherwise, it is equal to the character at index_k+start-n_ in the argument `s`.  
 If `s` is `null`, then this method appends characters as if the s parameter was a sequence containing the four characters `"null"`.  
Specified by:  
`[append](../../java/lang/Appendable.html#append%28java.lang.CharSequence,int,int%29)` in interface `[Appendable](../../java/lang/Appendable.html "interface in java.lang")`  
Parameters:  
`s` \- the sequence to append.  
`start` \- the starting index of the subsequence to be appended.  
`end` \- the end index of the subsequence to be appended.  
Returns:  
a reference to this object.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if`start` is negative, or`start` is greater than `end` or`end` is greater than `s.length()`  
* #### append  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") append(char[] str,  
                            int offset,  
                            int len)  
Appends the string representation of a subarray of the`char` array argument to this sequence.  
 Characters of the `char` array `str`, starting at index `offset`, are appended, in order, to the contents of this sequence. The length of this sequence increases by the value of `len`.  
 The overall effect is exactly as if the arguments were converted to a string by the method [String.valueOf(char\[\],int,int)](../../java/lang/String.html#valueOf%28char%5B%5D,int,int%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`str` \- the characters to be appended.  
`offset` \- the index of the first `char` to append.  
`len` \- the number of `char`s to append.  
Returns:  
a reference to this object.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if `offset < 0` or `len < 0` or `offset+len > str.length`  
* #### appendCodePoint  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") appendCodePoint(int codePoint)  
Appends the string representation of the `codePoint` argument to this sequence.  
 The argument is appended to the contents of this sequence. The length of this sequence increases by[Character.charCount(codePoint)](../../java/lang/Character.html#charCount%28int%29).  
 The overall effect is exactly as if the argument were converted to a `char` array by the method[Character.toChars(int)](../../java/lang/Character.html#toChars%28int%29) and the character in that array were then [appended](../../java/lang/StringBuilder.html#append%28char%5B%5D%29) to this character sequence.  
Parameters:  
`codePoint` \- a Unicode code point  
Returns:  
a reference to this object.  
Since:  
1.5  
* #### delete  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") delete(int start,  
                            int end)  
Removes the characters in a substring of this sequence. The substring begins at the specified `start` and extends to the character at index `end - 1` or to the end of the sequence if no such character exists. If`start` is equal to `end`, no changes are made.  
Parameters:  
`start` \- The beginning index, inclusive.  
`end` \- The ending index, exclusive.  
Returns:  
This object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if `start` is negative, greater than `length()`, or greater than `end`.  
* #### deleteCharAt  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") deleteCharAt(int index)  
Removes the `char` at the specified position in this sequence. This sequence is shortened by one `char`.  
Note: If the character at the given index is a supplementary character, this method does not remove the entire character. If correct handling of supplementary characters is required, determine the number of `char`s to remove by calling`Character.charCount(thisSequence.codePointAt(index))`, where `thisSequence` is this sequence.  
Parameters:  
`index` \- Index of `char` to remove  
Returns:  
This object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the `index` is negative or greater than or equal to`length()`.  
* #### replace  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") replace(int start,  
                             int end,  
                             [String](../../java/lang/String.html "class in java.lang") str)  
Replaces the characters in a substring of this sequence 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 sequence if no such character exists. First the characters in the substring are removed and then the specified`String` is inserted at `start`. (This sequence will be lengthened to accommodate the specified String if necessary.)  
Parameters:  
`start` \- The beginning index, inclusive.  
`end` \- The ending index, exclusive.  
`str` \- String that will replace previous contents.  
Returns:  
This object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if `start` is negative, greater than `length()`, or greater than `end`.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int index,  
                            char[] str,  
                            int offset,  
                            int len)  
Inserts the string representation of a subarray of the `str` array argument into this sequence. The subarray begins at the specified `offset` and extends `len` `char`s. The characters of the subarray are inserted into this sequence at the position indicated by `index`. The length of this sequence increases by `len` `char`s.  
Parameters:  
`index` \- position at which to insert subarray.  
`str` \- A `char` array.  
`offset` \- the index of the first `char` in subarray to be inserted.  
`len` \- the number of `char`s in the subarray to be inserted.  
Returns:  
This object  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if `index` is negative or greater than `length()`, or`offset` or `len` are negative, or`(offset+len)` is greater than`str.length`.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            [Object](../../java/lang/Object.html "class in java.lang") obj)  
Inserts the string representation of the `Object` argument into this character sequence.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(Object)](../../java/lang/String.html#valueOf%28java.lang.Object%29), and the characters of that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`obj` \- an `Object`.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            [String](../../java/lang/String.html "class in java.lang") str)  
Inserts the string into this character sequence.  
 The characters of the `String` argument are inserted, in order, into this sequence at the indicated offset, moving up any characters originally above that position and increasing the length of this sequence by the length of the argument. If`str` is `null`, then the four characters`"null"` are inserted into this sequence.  
 The character at index _k_ in the new character sequence is equal to:  
         * 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](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`str` \- a string.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            char[] str)  
Inserts the string representation of the `char` array argument into this sequence.  
 The characters of the array argument are inserted into the contents of this sequence at the position indicated by`offset`. The length of this sequence increases by the length of the argument.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(char\[\])](../../java/lang/String.html#valueOf%28char%5B%5D%29), and the characters of that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`str` \- a character array.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int dstOffset,  
                            [CharSequence](../../java/lang/CharSequence.html "interface in java.lang") s)  
Inserts the specified `CharSequence` into this sequence.  
 The characters of the `CharSequence` argument are inserted, in order, into this sequence at the indicated offset, moving up any characters originally above that position and increasing the length of this sequence by the length of the argument s.  
 The result of this method is exactly the same as if it were an invocation of this object's[insert](../../java/lang/StringBuilder.html#insert%28int,java.lang.CharSequence,int,int%29)(dstOffset, s, 0, s.length()) method.  
If `s` is `null`, then the four characters`"null"` are inserted into this sequence.  
Parameters:  
`dstOffset` \- the offset.  
`s` \- the sequence to be inserted  
Returns:  
a reference to this object.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int dstOffset,  
                            [CharSequence](../../java/lang/CharSequence.html "interface in java.lang") s,  
                            int start,  
                            int end)  
Inserts a subsequence of the specified `CharSequence` into this sequence.  
 The subsequence of the argument `s` specified by`start` and `end` are inserted, in order, into this sequence at the specified destination offset, moving up any characters originally above that position. The length of this sequence is increased by `end - start`.  
 The character at index _k_ in this sequence becomes equal to:  
         * the character at index _k_ in this sequence, if_k_ is less than `dstOffset`  
         * the character at index _k_`+start-dstOffset` in the argument `s`, if _k_ is greater than or equal to`dstOffset` but is less than `dstOffset+end-start`  
         * the character at index _k_`-(end-start)` in this sequence, if _k_ is greater than or equal to`dstOffset+end-start`  
 The `dstOffset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
The start argument must be nonnegative, and not greater than`end`.  
The end argument must be greater than or equal to`start`, and less than or equal to the length of s.  
If `s` is `null`, then this method inserts characters as if the s parameter was a sequence containing the four characters `"null"`.  
Parameters:  
`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.  
Returns:  
a reference to this object.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if `dstOffset` is negative or greater than `this.length()`, or`start` or `end` are negative, or`start` is greater than `end` or`end` is greater than `s.length()`  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            boolean b)  
Inserts the string representation of the `boolean` argument into this sequence.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(boolean)](../../java/lang/String.html#valueOf%28boolean%29), and the characters of that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`b` \- a `boolean`.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            char c)  
Inserts the string representation of the `char` argument into this sequence.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(char)](../../java/lang/String.html#valueOf%28char%29), and the character in that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`c` \- a `char`.  
Returns:  
a reference to this object.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            int i)  
Inserts the string representation of the second `int` argument into this sequence.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(int)](../../java/lang/String.html#valueOf%28int%29), and the characters of that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`i` \- an `int`.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            long l)  
Inserts the string representation of the `long` argument into this sequence.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(long)](../../java/lang/String.html#valueOf%28long%29), and the characters of that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`l` \- a `long`.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            float f)  
Inserts the string representation of the `float` argument into this sequence.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(float)](../../java/lang/String.html#valueOf%28float%29), and the characters of that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`f` \- a `float`.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### insert  
public [StringBuilder](../../java/lang/StringBuilder.html "class in java.lang") insert(int offset,  
                            double d)  
Inserts the string representation of the `double` argument into this sequence.  
 The overall effect is exactly as if the second argument were converted to a string by the method [String.valueOf(double)](../../java/lang/String.html#valueOf%28double%29), and the characters of that string were then[inserted](../../java/lang/StringBuilder.html#insert%28int,java.lang.String%29) into this character sequence at the indicated offset.  
 The `offset` argument must be greater than or equal to`0`, and less than or equal to the [length](../../java/lang/StringBuilder.html#length%28%29) of this sequence.  
Parameters:  
`offset` \- the offset.  
`d` \- a `double`.  
Returns:  
a reference to this object.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if the offset is invalid.  
* #### length  
public int length()  
Returns the length (character count).  
Specified by:  
`[length](../../java/lang/CharSequence.html#length%28%29)` in interface `[CharSequence](../../java/lang/CharSequence.html "interface in java.lang")`  
Returns:  
the length of the sequence of characters currently represented by this object  
* #### capacity  
public int capacity()  
Returns the current capacity. The capacity is the amount of storage available for newly inserted characters, beyond which an allocation will occur.  
Returns:  
the current capacity  
* #### ensureCapacity  
public void ensureCapacity(int minimumCapacity)  
Ensures that the capacity is at least equal to the specified minimum. If the current capacity is less than the argument, then a new internal array 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. Note that subsequent operations on this object can reduce the actual capacity below that requested here.  
Parameters:  
`minimumCapacity` \- the minimum desired capacity.  
* #### trimToSize  
public void trimToSize()  
Attempts to reduce storage used for the character sequence. If the buffer is larger than necessary to hold its current sequence of characters, then it may be resized to become more space efficient. Calling this method may, but is not required to, affect the value returned by a subsequent call to the [capacity()](../../java/lang/StringBuilder.html#capacity%28%29) method.  
* #### setLength  
public void setLength(int newLength)  
Sets the length of the character sequence. The sequence is changed to 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, the length is changed to the specified length.  
 If the `newLength` argument is greater than or equal to the current length, sufficient null characters (`'\u0000'`) are appended so that length becomes the `newLength` argument.  
 The `newLength` argument must be greater than or equal to `0`.  
Parameters:  
`newLength` \- the new length  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if the`newLength` argument is negative.  
* #### charAt  
public char charAt(int index)  
Returns the `char` value in this sequence at the specified index. The first `char` value is at index `0`, the next at index`1`, and so on, as in array indexing.  
 The index argument must be greater than or equal to`0`, and less than the length of this sequence.  
If the `char` value specified by the index is a[surrogate](Character.html#unicode), the surrogate value is returned.  
Specified by:  
`[charAt](../../java/lang/CharSequence.html#charAt%28int%29)` in interface `[CharSequence](../../java/lang/CharSequence.html "interface in java.lang")`  
Parameters:  
`index` \- the index of the desired `char` value.  
Returns:  
the `char` value at the specified index.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if `index` is negative or greater than or equal to `length()`.  
* #### codePointAt  
public int codePointAt(int index)  
Returns the character (Unicode code point) at the specified index. The index refers to `char` values (Unicode code units) and ranges from `0` to[length()](../../java/lang/StringBuilder.html#length%28%29)` - 1`.  
 If the `char` value specified at the given index is in the high-surrogate range, the following index is less than the length of this sequence, and the`char` value at the following index is in the low-surrogate range, then the supplementary code point corresponding to this surrogate pair is returned. Otherwise, the `char` value at the given index is returned.  
Parameters:  
`index` \- the index to the `char` values  
Returns:  
the code point value of the character at the`index`  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if the `index` argument is negative or not less than the length of this sequence.  
* #### codePointBefore  
public int codePointBefore(int index)  
Returns the character (Unicode code point) before the specified index. The index refers to `char` values (Unicode code units) and ranges from `1` to [length()](../../java/lang/StringBuilder.html#length%28%29).  
 If the `char` value at `(index - 1)` is in the low-surrogate range, `(index - 2)` is not negative, and the `char` value at `(index - 2)` is in the high-surrogate range, then the supplementary code point value of the surrogate pair is returned. If the `char` value at `index - 1` is an unpaired low-surrogate or a high-surrogate, the surrogate value is returned.  
Parameters:  
`index` \- the index following the code point that should be returned  
Returns:  
the Unicode code point value before the given index.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if the `index` argument is less than 1 or greater than the length of this sequence.  
* #### codePointCount  
public int codePointCount(int beginIndex,  
                          int endIndex)  
Returns the number of Unicode code points in the specified text range of this sequence. The text range begins at the specified`beginIndex` and extends to the `char` at index `endIndex - 1`. Thus the length (in`char`s) of the text range is`endIndex-beginIndex`. Unpaired surrogates within this sequence count as one code point each.  
Parameters:  
`beginIndex` \- the index to the first `char` of the text range.  
`endIndex` \- the index after the last `char` of the text range.  
Returns:  
the number of Unicode code points in the specified text range  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if the`beginIndex` is negative, or `endIndex` is larger than the length of this sequence, or`beginIndex` is larger than `endIndex`.  
* #### offsetByCodePoints  
public int offsetByCodePoints(int index,  
                              int codePointOffset)  
Returns the index within this sequence that is offset from the given `index` by `codePointOffset` code points. Unpaired surrogates within the text range given by`index` and `codePointOffset` count as one code point each.  
Parameters:  
`index` \- the index to be offset  
`codePointOffset` \- the offset in code points  
Returns:  
the index within this sequence  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if `index` is negative or larger then the length of this sequence, or if `codePointOffset` is positive and the subsequence starting with `index` has fewer than`codePointOffset` code points, or if `codePointOffset` is negative and the subsequence before `index` has fewer than the absolute value of`codePointOffset` code points.  
* #### getChars  
public void getChars(int srcBegin,  
                     int srcEnd,  
                     char[] dst,  
                     int dstBegin)  
Characters are copied from this sequence 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  
       
```  
Parameters:  
`srcBegin` \- start copying at this offset.  
`srcEnd` \- stop copying at this offset.  
`dst` \- the array to copy the data into.  
`dstBegin` \- offset into `dst`.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- 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()`.  
         * `dstBegin+srcEnd-srcBegin` is greater than`dst.length`  
* #### setCharAt  
public void setCharAt(int index,  
                      char ch)  
The character at the specified index is set to `ch`. This sequence is altered to represent a new character sequence that is identical to the old character sequence, except that it contains the character `ch` at position `index`.  
 The index argument must be greater than or equal to`0`, and less than the length of this sequence.  
Parameters:  
`index` \- the index of the character to modify.  
`ch` \- the new character.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if `index` is negative or greater than or equal to `length()`.  
* #### append  
public java.lang.AbstractStringBuilder append([Object](../../java/lang/Object.html "class in java.lang") obj)  
Appends the string representation of the `Object` argument.  
 The overall effect is exactly as if the argument were converted to a string by the method [String.valueOf(Object)](../../java/lang/String.html#valueOf%28java.lang.Object%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`obj` \- an `Object`.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append([String](../../java/lang/String.html "class in java.lang") str)  
Appends the specified string to this character sequence.  
 The characters of the `String` argument are appended, in order, increasing the length of this sequence by the length of the argument. If `str` is `null`, then the four characters `"null"` are appended.  
 Let _n_ be the length of this character sequence just prior to execution of the `append` method. Then the character at index _k_ in the new character sequence is equal to the character at index _k_ in the old character sequence, if _k_ is less than _n_; otherwise, it is equal to the character at index_k-n_ in the argument `str`.  
Parameters:  
`str` \- a string.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append([CharSequence](../../java/lang/CharSequence.html "interface in java.lang") s)  
Description copied from interface: `[Appendable](../../java/lang/Appendable.html#append%28java.lang.CharSequence%29)`  
Appends the specified character sequence to this `Appendable`.  
 Depending on which class implements the character sequence`csq`, the entire sequence may not be appended. For instance, if `csq` is a [CharBuffer](../../java/nio/CharBuffer.html "class in java.nio") then the subsequence to append is defined by the buffer's position and limit.  
Specified by:  
`[append](../../java/lang/Appendable.html#append%28java.lang.CharSequence%29)` in interface `[Appendable](../../java/lang/Appendable.html "interface in java.lang")`  
Parameters:  
`s` \- The character sequence to append. If `csq` is`null`, then the four characters `"null"` are appended to this Appendable.  
Returns:  
A reference to this `Appendable`  
* #### append  
public java.lang.AbstractStringBuilder append(char[] str)  
Appends the string representation of the `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 method [String.valueOf(char\[\])](../../java/lang/String.html#valueOf%28char%5B%5D%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`str` \- the characters to be appended.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append(boolean b)  
Appends the string representation of the `boolean` argument to the sequence.  
 The overall effect is exactly as if the argument were converted to a string by the method [String.valueOf(boolean)](../../java/lang/String.html#valueOf%28boolean%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`b` \- a `boolean`.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append(char c)  
Appends the string representation of the `char` argument to this sequence.  
 The argument is appended to the contents of this sequence. The length of this sequence increases by `1`.  
 The overall effect is exactly as if the argument were converted to a string by the method [String.valueOf(char)](../../java/lang/String.html#valueOf%28char%29), and the character in that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Specified by:  
`[append](../../java/lang/Appendable.html#append%28char%29)` in interface `[Appendable](../../java/lang/Appendable.html "interface in java.lang")`  
Parameters:  
`c` \- a `char`.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append(int i)  
Appends the string representation of the `int` argument to this sequence.  
 The overall effect is exactly as if the argument were converted to a string by the method [String.valueOf(int)](../../java/lang/String.html#valueOf%28int%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`i` \- an `int`.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append(long l)  
Appends the string representation of the `long` argument to this sequence.  
 The overall effect is exactly as if the argument were converted to a string by the method [String.valueOf(long)](../../java/lang/String.html#valueOf%28long%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`l` \- a `long`.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append(float f)  
Appends the string representation of the `float` argument to this sequence.  
 The overall effect is exactly as if the argument were converted to a string by the method [String.valueOf(float)](../../java/lang/String.html#valueOf%28float%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`f` \- a `float`.  
Returns:  
a reference to this object.  
* #### append  
public java.lang.AbstractStringBuilder append(double d)  
Appends the string representation of the `double` argument to this sequence.  
 The overall effect is exactly as if the argument were converted to a string by the method [String.valueOf(double)](../../java/lang/String.html#valueOf%28double%29), and the characters of that string were then[appended](../../java/lang/StringBuilder.html#append%28java.lang.String%29) to this character sequence.  
Parameters:  
`d` \- a `double`.  
Returns:  
a reference to this object.  
* #### substring  
public [String](../../java/lang/String.html "class in java.lang") substring(int start)  
Returns a new `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.  
Parameters:  
`start` \- The beginning index, inclusive.  
Returns:  
The new string.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if `start` is less than zero, or greater than the length of this object.  
* #### subSequence  
public [CharSequence](../../java/lang/CharSequence.html "interface in java.lang") subSequence(int start,  
                                int end)  
Returns a new character sequence that is a subsequence of this sequence.  
 An invocation of this method of the form  
```  
 sb.subSequence(begin,&nbsp;end)  
```  
 behaves in exactly the same way as the invocation  
```  
 sb.substring(begin,&nbsp;end)  
```  
 This method is provided so that this class can implement the [CharSequence](../../java/lang/CharSequence.html "interface in java.lang") interface.  
Specified by:  
`[subSequence](../../java/lang/CharSequence.html#subSequence%28int,int%29)` in interface `[CharSequence](../../java/lang/CharSequence.html "interface in java.lang")`  
Parameters:  
`start` \- the start index, inclusive.  
`end` \- the end index, exclusive.  
Returns:  
the specified subsequence.  
Throws:  
`[IndexOutOfBoundsException](../../java/lang/IndexOutOfBoundsException.html "class in java.lang")` \- if `start` or `end` are negative, if `end` is greater than `length()`, or if `start` is greater than `end`  
* #### substring  
public [String](../../java/lang/String.html "class in java.lang") substring(int start,  
                        int end)  
Returns a new `String` that contains a subsequence of characters currently contained in this sequence. The substring begins at the specified `start` and extends to the character at index `end - 1`.  
Parameters:  
`start` \- The beginning index, inclusive.  
`end` \- The ending index, exclusive.  
Returns:  
The new string.  
Throws:  
`[StringIndexOutOfBoundsException](../../java/lang/StringIndexOutOfBoundsException.html "class in java.lang")` \- if `start` or `end` are negative or greater than`length()`, or `start` is greater than `end`.  
* #### indexOf  
public int indexOf([String](../../java/lang/String.html "class in java.lang") str)  
Returns the index within this string of the first occurrence of the specified substring.  
The returned index is the smallest value `k` for which:  
```  
 this.toString().startsWith(str, k)  
       
```  
 If no such value of `k` exists, then `-1` is returned.  
Parameters:  
`str` \- the substring to search for.  
Returns:  
the index of the first occurrence of the specified substring, or `-1` if there is no such occurrence.  
* #### indexOf  
public int indexOf([String](../../java/lang/String.html "class in java.lang") str,  
                   int fromIndex)  
Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.  
The returned index is the smallest value `k` for which:  
```  
     k >= Math.min(fromIndex, this.length()) &&  
                   this.toString().startsWith(str, k)  
       
```  
 If no such value of `k` exists, then `-1` is returned.  
Parameters:  
`str` \- the substring to search for.  
`fromIndex` \- the index from which to start the search.  
Returns:  
the index of the first occurrence of the specified substring, starting at the specified index, or `-1` if there is no such occurrence.  
* #### lastIndexOf  
public int lastIndexOf([String](../../java/lang/String.html "class in java.lang") str)  
Returns the index within this string of the last occurrence of the specified substring. The last occurrence of the empty string "" is considered to occur at the index value `this.length()`.  
The returned index is the largest value `k` for which:  
```  
 this.toString().startsWith(str, k)  
       
```  
 If no such value of `k` exists, then `-1` is returned.  
Parameters:  
`str` \- the substring to search for.  
Returns:  
the index of the last occurrence of the specified substring, or `-1` if there is no such occurrence.  
* #### lastIndexOf  
public int lastIndexOf([String](../../java/lang/String.html "class in java.lang") str,  
                       int fromIndex)  
Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index.  
The returned index is the largest value `k` for which:  
```  
     k <= Math.min(fromIndex, this.length()) &&  
                   this.toString().startsWith(str, k)  
       
```  
 If no such value of `k` exists, then `-1` is returned.  
Parameters:  
`str` \- the substring to search for.  
`fromIndex` \- the index to start the search from.  
Returns:  
the index of the last occurrence of the specified substring, searching backward from the specified index, or `-1` if there is no such occurrence.  
* #### reverse  
public java.lang.AbstractStringBuilder reverse()  
Causes this character sequence to be replaced by the reverse of the sequence. If there are any surrogate pairs included in the sequence, these are treated as single characters for the reverse operation. Thus, the order of the high-low surrogates is never reversed. Let _n_ be the character length of this character sequence (not the length in `char` values) just prior to execution of the `reverse` method. Then the character at index _k_ in the new character sequence is equal to the character at index _n-k-1_ in the old character sequence.  
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.  
Returns:  
a reference to this object.  
* #### toString  
public abstract [String](../../java/lang/String.html "class in java.lang") toString()  
Returns a string representing the data in this sequence. A new `String` object is allocated and initialized to contain the character sequence currently represented by this object. This `String` is then returned. Subsequent changes to this sequence do not affect the contents of the`String`.  
Specified by:  
`[toString](../../java/lang/CharSequence.html#toString%28%29)` in interface `[CharSequence](../../java/lang/CharSequence.html "interface in java.lang")`  
Overrides:  
`[toString](../../java/lang/Object.html#toString%28%29)` in class `[Object](../../java/lang/Object.html "class in java.lang")`  
Returns:  
a string representation of this sequence of characters.  
* #### chars  
public [IntStream](../../java/util/stream/IntStream.html "interface in java.util.stream") chars()  
Returns a stream of `int` zero-extending the `char` values from this sequence. Any char which maps to a [surrogate code point](../../java/lang/Character.html#unicode) is passed through uninterpreted.  
The stream binds to this sequence when the terminal stream operation commences (specifically, for mutable sequences the spliterator for the stream is [_late-binding_](../util/Spliterator.html#binding)). If the sequence is modified during that operation then the result is undefined.  
Specified by:  
`[chars](../../java/lang/CharSequence.html#chars%28%29)` in interface `[CharSequence](../../java/lang/CharSequence.html "interface in java.lang")`  
Returns:  
an IntStream of char values from this sequence  
Since:  
9  
* #### codePoints  
public [IntStream](../../java/util/stream/IntStream.html "interface in java.util.stream") codePoints()  
Returns a stream of code point values from this sequence. Any surrogate pairs encountered in the sequence are combined as if by [Character.toCodePoint](../../java/lang/Character.html#toCodePoint%28char,char%29) and the result is passed to the stream. Any other code units, including ordinary BMP characters, unpaired surrogates, and undefined code units, are zero-extended to`int` values which are then passed to the stream.  
The stream binds to this sequence when the terminal stream operation commences (specifically, for mutable sequences the spliterator for the stream is [_late-binding_](../util/Spliterator.html#binding)). If the sequence is modified during that operation then the result is undefined.  
Specified by:  
`[codePoints](../../java/lang/CharSequence.html#codePoints%28%29)` in interface `[CharSequence](../../java/lang/CharSequence.html "interface in java.lang")`  
Returns:  
an IntStream of Unicode code points from this sequence  
Since:  
9

StringBuilder (Java SE 10 & JDK 10 ) (original) (raw)

Constructor Summary

Method Summary

Constructor Detail

Method Detail