@Override
@HotSpotIntrinsicCandidate
public synchronized StringBuffer append(int i) {
toStringCache = null;
super.append(i);
return this;
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @since 1.5
*/
@Override
public StringBuffer insert(int dstOffset, CharSequence s) {
// Note, synchronization achieved via invocations of other StringBuffer methods
// after narrowing of s to specific type
// Ditto for toStringCache clearing
super.insert(dstOffset, s);
return this;
}
/** @throws StringIndexOutOfBoundsException {@inheritDoc} */
@Override
public StringBuffer insert(int offset, double d) {
// Note, synchronization achieved via invocation of StringBuffer insert(int, String)
// after conversion of d to String by super class method
// Ditto for toStringCache clearing
super.insert(offset, d);
return this;
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @see #length()
*/
public synchronized StringBuffer insert(int offset, char c) {
super.insert(offset, c);
return this;
}
/**
* @throws StringIndexOutOfBoundsException {@inheritDoc}
* @see #length()
*/
public synchronized StringBuffer insert(int offset, String str) {
super.insert(offset, str);
return this;
}
/**
* @throws StringIndexOutOfBoundsException {@inheritDoc}
* @since 1.2
*/
public synchronized StringBuffer insert(int index, char str[], int offset, int len) {
super.insert(index, str, offset, len);
return this;
}
/**
* @throws StringIndexOutOfBoundsException {@inheritDoc}
* @since 1.2
*/
public synchronized StringBuffer deleteCharAt(int index) {
super.deleteCharAt(index);
return this;
}
/**
* @see java.lang.String#valueOf(double)
* @see #append(java.lang.String)
*/
public synchronized StringBuffer append(double d) {
super.append(d);
return this;
}
/**
* @see java.lang.String#valueOf(long)
* @see #append(java.lang.String)
*/
public synchronized StringBuffer append(long lng) {
super.append(lng);
return this;
}
/**
* @throws NullPointerException {@inheritDoc}
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public synchronized void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {
super.getChars(srcBegin, srcEnd, dst, dstBegin);
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @see #length()
*/
public synchronized void setLength(int newLength) {
super.setLength(newLength);
}
/** @since 1.5 */
public synchronized void trimToSize() {
super.trimToSize();
}
/** @since 1.0.2 */
@Override
public synchronized StringBuffer reverse() {
toStringCache = null;
super.reverse();
return this;
}
/** @throws IndexOutOfBoundsException {@inheritDoc} */
@Override
public synchronized StringBuffer insert(int offset, char c) {
toStringCache = null;
super.insert(offset, c);
return this;
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @since 1.5
*/
@Override
public synchronized StringBuffer insert(int dstOffset, CharSequence s, int start, int end) {
toStringCache = null;
super.insert(dstOffset, s, start, end);
return this;
}
/**
* @see java.lang.String#valueOf(int)
* @see #append(java.lang.String)
*/
public synchronized StringBuffer append(int i) {
super.append(i);
return this;
}
/** @since 1.5 */
public synchronized StringBuffer appendCodePoint(int codePoint) {
super.appendCodePoint(codePoint);
return this;
}
/**
* @see java.lang.String#valueOf(java.lang.Object)
* @see #append(java.lang.String)
*/
public synchronized StringBuffer append(Object obj) {
super.append(String.valueOf(obj));
return this;
}
/**
* @see java.lang.String#valueOf(float)
* @see #append(java.lang.String)
*/
public synchronized StringBuffer append(float f) {
super.append(f);
return this;
}
/**
* Appends the specified <tt>StringBuffer</tt> to this sequence.
*
* <p>The characters of the <tt>StringBuffer</tt> argument are appended, in order, to the contents
* of this <tt>StringBuffer</tt>, increasing the length of this <tt>StringBuffer</tt> by the
* length of the argument. If <tt>sb</tt> is <tt>null</tt>, then the four characters
* <tt>"null"</tt> are appended to this <tt>StringBuffer</tt>.
*
* <p>Let <i>n</i> be the length of the old character sequence, the one contained in the
* <tt>StringBuffer</tt> just prior to execution of the <tt>append</tt> method. Then the character
* at index <i>k</i> in the new character sequence is equal to the character at index <i>k</i> in
* the old character sequence, if <i>k</i> is less than <i>n</i>; otherwise, it is equal to the
* character at index <i>k-n</i> in the argument <code>sb</code>.
*
* <p>This method synchronizes on <code>this</code> (the destination) object but does not
* synchronize on the source (<code>sb</code>).
*
* @param sb the <tt>StringBuffer</tt> to append.
* @return a reference to this object.
* @since 1.4
*/
public synchronized StringBuffer append(StringBuffer sb) {
super.append(sb);
return this;
}
/**
* @throws StringIndexOutOfBoundsException {@inheritDoc}
* @since 1.2
*/
public synchronized StringBuffer delete(int start, int end) {
super.delete(start, end);
return this;
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @since 1.5
*/
public synchronized StringBuffer append(CharSequence s, int start, int end) {
super.append(s, start, end);
return this;
}
/**
* @throws StringIndexOutOfBoundsException {@inheritDoc}
* @since 1.2
*/
public synchronized StringBuffer replace(int start, int end, String str) {
super.replace(start, end, str);
return this;
}
public synchronized StringBuffer append(char str[]) {
super.append(str);
return this;
}
/**
* @throws StringIndexOutOfBoundsException {@inheritDoc}
* @see java.lang.String#valueOf(java.lang.Object)
* @see #insert(int, java.lang.String)
* @see #length()
*/
public synchronized StringBuffer insert(int offset, Object obj) {
super.insert(offset, String.valueOf(obj));
return this;
}
public synchronized StringBuffer append(char str[], int offset, int len) {
super.append(str, offset, len);
return this;
}
/**
* @throws IndexOutOfBoundsException {@inheritDoc}
* @since 1.5
*/
public synchronized StringBuffer insert(int dstOffset, CharSequence s, int start, int end) {
super.insert(dstOffset, s, start, end);
return this;
}
/**
* @see java.lang.String#valueOf(boolean)
* @see #append(java.lang.String)
*/
public synchronized StringBuffer append(boolean b) {
super.append(b);
return this;
}
/** @since JDK1.0.2 */
public synchronized StringBuffer reverse() {
super.reverse();
return this;
}
public synchronized StringBuffer append(char c) {
super.append(c);
return this;
}