public StringBuffer() 
{
        super(16);
}

Constructs a string buffer with no characters in it and an initial capacity of 16 characters.

 public StringBuffer(int capacity) 
{
        super(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.

exception: NegativeArraySizeException - if the capacity argument is less than 0.

 public StringBuffer(String str) 
{
        super(str.length() + 16);
        append(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.

Throws:

NullPointerException - if str is null

exception: NullPointerException - if str is null

 public StringBuffer(CharSequence seq) 
{
        this(seq.length() + 16);
        append(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.

Throws:

NullPointerException - if seq is null

exception: NullPointerException - if seq is null

since: 1.5 -

 public synchronized StringBuffer append(Object obj) 
{
        super.append(String.valueOf(obj));
        return this;
}

 public synchronized StringBuffer append(String str) 
{
        super.append(str);
        return this;
}

 public synchronized StringBuffer append(StringBuffer sb) 
{
        super.append(sb);
        return this;
}

Appends the specified StringBuffer to this sequence.

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.

This method synchronizes on this (the destination) object but does not synchronize on the source (sb).

 public StringBuffer append(CharSequence s) 
{
        // Note, synchronization achieved via other invocations
        if (s == null)
            s = "null";
        if (s instanceof String)
            return this.append((String)s);
        if (s instanceof StringBuffer)
            return this.append((StringBuffer)s);
        return this.append(s, 0, s.length());
}

Appends the specified CharSequence to this sequence.

The characters of the CharSequence argument are appended, in order, increasing the length of this sequence by the length of the argument.

The result of this method is exactly the same as if it were an invocation of this.append(s, 0, s.length());

This method synchronizes on this (the destination) object but does not synchronize on the source (s).

If s is null, then the four characters "null" are appended.

 public synchronized StringBuffer append(char[] str) 
{
        super.append(str);
        return this;
}

 public synchronized StringBuffer append(boolean b) 
{
        super.append(b);
        return this;
}

 public synchronized StringBuffer append(char c) 
{
        super.append(c);
        return this;
}

 public synchronized StringBuffer append(int i) 
{
        super.append(i);
        return this;
}

 public synchronized StringBuffer append(long lng) 
{
        super.append(lng);
        return this;
}

 public synchronized StringBuffer append(float f) 
{
        super.append(f);
        return this;
}

 public synchronized StringBuffer append(double d) 
{
        super.append(d);
        return this;
}

 public synchronized StringBuffer append(CharSequence s,
    int start,
    int end) 
{
        super.append(s, start, end);
        return this;
}

 public synchronized StringBuffer append(char[] str,
    int offset,
    int len) 
{
        super.append(str, offset, len);
        return this;
}

 public synchronized StringBuffer appendCodePoint(int codePoint) 
{
        super.appendCodePoint(codePoint);
        return this;
}

 public synchronized int capacity() 
{
        return value.length;
}

 public synchronized char charAt(int index) 
{
        if ((index <  0) || (index  >= count))
            throw new StringIndexOutOfBoundsException(index);
        return value[index];
}

 public synchronized int codePointAt(int index) 
{
        return super.codePointAt(index);
}

 public synchronized int codePointBefore(int index) 
{
        return super.codePointBefore(index);
}

 public synchronized int codePointCount(int beginIndex,
    int endIndex) 
{
        return super.codePointCount(beginIndex, endIndex);
}

 public synchronized StringBuffer delete(int start,
    int end) 
{
        super.delete(start, end);
        return this;
}

 public synchronized StringBuffer deleteCharAt(int index) 
{
        super.deleteCharAt(index);
        return this;
}

 public synchronized  void ensureCapacity(int minimumCapacity) 
{
        if (minimumCapacity  > value.length) {
            expandCapacity(minimumCapacity);
        }
}

 public synchronized  void getChars(int srcBegin,
    int srcEnd,
    char[] dst,
    int dstBegin) 
{
        super.getChars(srcBegin, srcEnd, dst, dstBegin);
}

 public int indexOf(String str) 
{
        return indexOf(str, 0);
}

 public synchronized int indexOf(String str,
    int fromIndex) 
{
        return String.indexOf(value, 0, count,
                              str.toCharArray(), 0, str.length(), fromIndex);
}

 public synchronized StringBuffer insert(int offset,
    Object obj) 
{
        super.insert(offset, String.valueOf(obj));
        return this;
}

 public synchronized StringBuffer insert(int offset,
    String str) 
{
        super.insert(offset, str);
        return this;
}

 public synchronized StringBuffer insert(int offset,
    char[] str) 
{
        super.insert(offset, str);
        return this;
}

 public StringBuffer insert(int dstOffset,
    CharSequence s) 
{
        // Note, synchronization achieved via other invocations
        if (s == null)
            s = "null";
        if (s instanceof String)
            return this.insert(dstOffset, (String)s);
        return this.insert(dstOffset, s, 0, s.length());
}

 public StringBuffer insert(int offset,
    boolean b) 
{
        return insert(offset, String.valueOf(b));
}

 public synchronized StringBuffer insert(int offset,
    char c) 
{
        super.insert(offset, c);
        return this;
}

 public StringBuffer insert(int offset,
    int i) 
{
        return insert(offset, String.valueOf(i));
}

 public StringBuffer insert(int offset,
    long l) 
{
        return insert(offset, String.valueOf(l));
}

 public StringBuffer insert(int offset,
    float f) 
{
        return insert(offset, String.valueOf(f));
}

 public StringBuffer insert(int offset,
    double d) 
{
        return insert(offset, String.valueOf(d));
}

 public synchronized StringBuffer insert(int index,
    char[] str,
    int offset,
    int len) 
{
        super.insert(index, str, offset, len);
        return this;
}

 public synchronized StringBuffer insert(int dstOffset,
    CharSequence s,
    int start,
    int end) 
{
        super.insert(dstOffset, s, start, end);
        return this;
}

 public int lastIndexOf(String str) 
{
        // Note, synchronization achieved via other invocations
        return lastIndexOf(str, count);
}

 public synchronized int lastIndexOf(String str,
    int fromIndex) 
{
        return String.lastIndexOf(value, 0, count,
                              str.toCharArray(), 0, str.length(), fromIndex);
}

 public synchronized int length() 
{
        return count;
}

 public synchronized int offsetByCodePoints(int index,
    int codePointOffset) 
{
        return super.offsetByCodePoints(index, codePointOffset);
}

 public synchronized StringBuffer replace(int start,
    int end,
    String str) 
{
        super.replace(start, end, str);
        return this;
}

 public synchronized StringBuffer reverse() 
{
        super.reverse();
        return this;
}

 public synchronized  void setCharAt(int index,
    char ch) 
{
        if ((index <  0) || (index  >= count))
            throw new StringIndexOutOfBoundsException(index);
        value[index] = ch;
}

 public synchronized  void setLength(int newLength) 
{
        super.setLength(newLength);
}

 public synchronized CharSequence subSequence(int start,
    int end) 
{
        return super.substring(start, end);
}

 public synchronized String substring(int start) 
{
        return substring(start, count);
}

 public synchronized String substring(int start,
    int end) 
{
        return super.substring(start, end);
}

 public synchronized String toString() 
{
        return new String(value, 0, count);
}

 public synchronized  void trimToSize() 
{
        super.trimToSize();
}