StringBuffer (Java Platform SE 8 )

java.lang.Object
- java.lang.StringBuffer

All Implemented Interfaces:

Serializable, Appendable, CharSequence
```
public final class StringBuffer
extends Object
implements Serializable, CharSequence
```
A thread-safe, mutable sequence of characters. A string buffer is like a String, but can be modified. At any point in time it contains some particular sequence of characters, but the length and content of the sequence can be changed through certain method calls.
String buffers are safe for use by multiple threads. The methods are synchronized where necessary so that all the operations on any particular instance behave as if they occur in some serial order that is consistent with the order of the method calls made by each of the individual threads involved.
The principal operations on a StringBuffer are the append and insert methods, which are overloaded so as to accept data of any type. Each effectively converts a given datum to a string and then appends or inserts the characters of that string to the string buffer. The append method always adds these characters at the end of the buffer; the insert method adds the characters at a specified point.
For example, if z refers to a string buffer object whose current contents are "start", then the method call z.append("le") would cause the string buffer to contain "startle", whereas z.insert(4, "le") would alter the string buffer to contain "starlet".
In general, if sb refers to an instance of a StringBuffer, then sb.append(x) has the same effect as sb.insert(sb.length(), x).
Whenever an operation occurs involving a source sequence (such as appending or inserting from a source sequence), this class synchronizes only on the string buffer performing the operation, not on the source. Note that while StringBuffer is designed to be safe to use concurrently from multiple threads, if the constructor or the append or insert operation is passed a source sequence that is shared across threads, the calling code must ensure that the operation has a consistent and unchanging view of the source sequence for the duration of the operation. This could be satisfied by the caller holding a lock during the operation's call, by using an immutable source sequence, or by not sharing the source sequence across threads.
Every string buffer has a capacity. As long as the length of the character sequence contained in the string buffer does not exceed the capacity, it is not necessary to allocate a new internal buffer array. If the internal buffer overflows, it is automatically made larger.
Unless otherwise noted, passing a null argument to a constructor or method in this class will cause a NullPointerException to be thrown.
As of release JDK 5, this class has been supplemented with an equivalent class designed for use by a single thread, StringBuilder. The StringBuilder class should generally be used in preference to this one, as it supports all of the same operations but it is faster, as it performs no synchronization.

Since:

JDK1.0

See Also:

StringBuilder, String, Serialized Form

Constructor Summary

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

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`StringBuffer`	`append(boolean b)`	Appends the string representation of the `boolean` argument to the sequence.
`StringBuffer`	`append(char c)`	Appends the string representation of the `char` argument to this sequence.
`StringBuffer`	`append(char[] str)`	Appends the string representation of the `char` array argument to this sequence.
`StringBuffer`	`append(char[] str, int offset, int len)`	Appends the string representation of a subarray of the `char` array argument to this sequence.
`StringBuffer`	`append(CharSequence s)`	Appends the specified `CharSequence` to this sequence.
`StringBuffer`	`append(CharSequence s, int start, int end)`	Appends a subsequence of the specified `CharSequence` to this sequence.
`StringBuffer`	`append(double d)`	Appends the string representation of the `double` argument to this sequence.
`StringBuffer`	`append(float f)`	Appends the string representation of the `float` argument to this sequence.
`StringBuffer`	`append(int i)`	Appends the string representation of the `int` argument to this sequence.
`StringBuffer`	`append(long lng)`	Appends the string representation of the `long` argument to this sequence.
`StringBuffer`	`append(Object obj)`	Appends the string representation of the `Object` argument.
`StringBuffer`	`append(String str)`	Appends the specified string to this character sequence.
`StringBuffer`	`append(StringBuffer sb)`	Appends the specified `StringBuffer` to this sequence.
`StringBuffer`	`appendCodePoint(int codePoint)`	Appends the string representation of the `codePoint` argument to this sequence.
`int`	`capacity()`	Returns the current capacity.
`char`	`charAt(int index)`	Returns the `char` value in this sequence at the specified index.
`int`	`codePointAt(int index)`	Returns the character (Unicode code point) at the specified index.
`int`	`codePointBefore(int index)`	Returns the character (Unicode code point) before the specified index.
`int`	`codePointCount(int beginIndex, int endIndex)`	Returns the number of Unicode code points in the specified text range of this sequence.
`StringBuffer`	`delete(int start, int end)`	Removes the characters in a substring of this sequence.
`StringBuffer`	`deleteCharAt(int index)`	Removes the `char` at the specified position in this sequence.
`void`	`ensureCapacity(int minimumCapacity)`	Ensures that the capacity is at least equal to the specified minimum.
`void`	`getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)`	Characters are copied from this sequence into the destination character array `dst`.
`int`	`indexOf(String str)`	Returns the index within this string of the first occurrence of the specified substring.
`int`	`indexOf(String str, int fromIndex)`	Returns the index within this string of the first occurrence of the specified substring, starting at the specified index.
`StringBuffer`	`insert(int offset, boolean b)`	Inserts the string representation of the `boolean` argument into this sequence.
`StringBuffer`	`insert(int offset, char c)`	Inserts the string representation of the `char` argument into this sequence.
`StringBuffer`	`insert(int offset, char[] str)`	Inserts the string representation of the `char` array argument into this sequence.
`StringBuffer`	`insert(int index, char[] str, int offset, int len)`	Inserts the string representation of a subarray of the `str` array argument into this sequence.
`StringBuffer`	`insert(int dstOffset, CharSequence s)`	Inserts the specified `CharSequence` into this sequence.
`StringBuffer`	`insert(int dstOffset, CharSequence s, int start, int end)`	Inserts a subsequence of the specified `CharSequence` into this sequence.
`StringBuffer`	`insert(int offset, double d)`	Inserts the string representation of the `double` argument into this sequence.
`StringBuffer`	`insert(int offset, float f)`	Inserts the string representation of the `float` argument into this sequence.
`StringBuffer`	`insert(int offset, int i)`	Inserts the string representation of the second `int` argument into this sequence.
`StringBuffer`	`insert(int offset, long l)`	Inserts the string representation of the `long` argument into this sequence.
`StringBuffer`	`insert(int offset, Object obj)`	Inserts the string representation of the `Object` argument into this character sequence.
`StringBuffer`	`insert(int offset, String str)`	Inserts the string into this character sequence.
`int`	`lastIndexOf(String str)`	Returns the index within this string of the rightmost occurrence of the specified substring.
`int`	`lastIndexOf(String str, int fromIndex)`	Returns the index within this string of the last occurrence of the specified substring.
`int`	`length()`	Returns the length (character count).
`int`	`offsetByCodePoints(int index, int codePointOffset)`	Returns the index within this sequence that is offset from the given `index` by `codePointOffset` code points.
`StringBuffer`	`replace(int start, int end, String str)`	Replaces the characters in a substring of this sequence with characters in the specified `String`.
`StringBuffer`	`reverse()`	Causes this character sequence to be replaced by the reverse of the sequence.
`void`	`setCharAt(int index, char ch)`	The character at the specified index is set to `ch`.
`void`	`setLength(int newLength)`	Sets the length of the character sequence.
`CharSequence`	`subSequence(int start, int end)`	Returns a new character sequence that is a subsequence of this sequence.
`String`	`substring(int start)`	Returns a new `String` that contains a subsequence of characters currently contained in this character sequence.
`String`	`substring(int start, int end)`	Returns a new `String` that contains a subsequence of characters currently contained in this sequence.
`String`	`toString()`	Returns a string representing the data in this sequence.
`void`	`trimToSize()`	Attempts to reduce storage used for the character sequence.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence
chars, codePoints

- Constructor Detail
  - StringBuffer
```
public StringBuffer()
```
    Constructs a string buffer with no characters in it and an initial capacity of 16 characters.
  - StringBuffer
```
public StringBuffer(int capacity)
```
    Constructs a string buffer with no characters in it and the specified initial capacity.
    
    Parameters:
    
    capacity - the initial capacity.
    
    Throws:
    
    NegativeArraySizeException - if the capacity argument is less than 0.
  - StringBuffer
```
public StringBuffer(String str)
```
    Constructs a string buffer initialized to the contents of the specified string. The initial capacity of the string buffer is 16 plus the length of the string argument.
    
    Parameters:
    
    str - the initial contents of the buffer.
  - StringBuffer
```
public StringBuffer(CharSequence seq)
```
    Constructs a string buffer that contains the same characters as the specified CharSequence. The initial capacity of the string buffer is 16 plus the length of the CharSequence argument.
    If the length of the specified CharSequence is less than or equal to zero, then an empty buffer of capacity 16 is returned.
    
    Parameters:
    
    seq - the sequence to copy.
    
    Since:
    
    1.5
- Method Detail
  - length
```
public int length()
```
    Returns the length (character count).
    
    Specified by:
    
    length in interface

Class StringBuffer

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Constructor Detail

StringBuffer

StringBuffer

StringBuffer

StringBuffer

Method Detail

length