mirror of
git://gcc.gnu.org/git/gcc.git
synced 2024-12-30 18:25:35 +08:00
de2baf30bb
* java/lang/StringBuffer.java (getChars): Remove wrong dstOffset check
against count.
From-SVN: r60616
729 lines
27 KiB
Java
729 lines
27 KiB
Java
/* StringBuffer.java -- Growable strings
|
|
Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
02111-1307 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package java.lang;
|
|
import java.io.Serializable;
|
|
|
|
/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
|
|
* Updated using online JDK 1.2 docs.
|
|
* Believed complete and correct to JDK 1.2.
|
|
* Merged with Classpath.
|
|
*/
|
|
|
|
/**
|
|
* <code>StringBuffer</code> represents a changeable <code>String</code>.
|
|
* It provides the operations required to modify the
|
|
* <code>StringBuffer</code> including insert, replace, delete, append,
|
|
* and reverse.
|
|
* <P>
|
|
*
|
|
* <code>StringBuffer</code>s are variable-length in nature, so even if
|
|
* you initialize them to a certain size, they can still grow larger than
|
|
* that. <EM>Capacity</EM> indicates the number of characters the
|
|
* <code>StringBuffer</code> can have in it before it has to grow (growing
|
|
* the char array is an expensive operation involving <code>new</code>).
|
|
* <P>
|
|
*
|
|
* Incidentally, the String operator "+" actually is turned into a
|
|
* <code>StringBuffer</code> operation:
|
|
* <BR>
|
|
* <code>a + b</code>
|
|
* <BR>
|
|
* is the same as
|
|
* <BR>
|
|
* <code>new StringBuffer(a).append(b).toString()</code>.
|
|
*
|
|
* @implnote Classpath's StringBuffer is capable of sharing memory with
|
|
* Strings for efficiency. This will help in two instances:
|
|
* first, when a StringBuffer is created from a String but is
|
|
* never changed, and second, when a StringBuffer is converted
|
|
* to a String and the StringBuffer is not changed after that.
|
|
*
|
|
* @since JDK1.0
|
|
* @author Paul Fisher
|
|
* @author John Keiser
|
|
* @author Tom Tromey
|
|
* @see java.lang.String
|
|
*/
|
|
public final class StringBuffer implements Serializable, CharSequence
|
|
{
|
|
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param bool the <code>boolean</code> to convert and append.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(boolean)
|
|
*/
|
|
public StringBuffer append (boolean bool)
|
|
{
|
|
return append (String.valueOf(bool));
|
|
}
|
|
|
|
/** Append the <code>char</code> to this <code>StringBuffer</code>.
|
|
* @param c the <code>char</code> to append.
|
|
* @return this <code>StringBuffer</code>.
|
|
*/
|
|
public synchronized StringBuffer append (char ch)
|
|
{
|
|
ensureCapacity_unsynchronized (count + 1);
|
|
value[count++] = ch;
|
|
return this;
|
|
}
|
|
|
|
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param inum the <code>int</code> to convert and append.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(int)
|
|
*/
|
|
public native StringBuffer append (int inum);
|
|
|
|
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param lnum the <code>long</code> to convert and append.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(long)
|
|
*/
|
|
public StringBuffer append (long lnum)
|
|
{
|
|
return append (String.valueOf(lnum));
|
|
}
|
|
|
|
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param fnum the <code>float</code> to convert and append.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(float)
|
|
*/
|
|
public StringBuffer append (float fnum)
|
|
{
|
|
return append (String.valueOf(fnum));
|
|
}
|
|
|
|
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param dnum the <code>double</code> to convert and append.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(double)
|
|
*/
|
|
public StringBuffer append (double dnum)
|
|
{
|
|
return append (String.valueOf(dnum));
|
|
}
|
|
|
|
/** Append the <code>String</code> value of the argument to this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param obj the <code>Object</code> to convert and append.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(java.lang.Object)
|
|
*/
|
|
public StringBuffer append (Object obj)
|
|
{
|
|
return append (String.valueOf(obj));
|
|
}
|
|
|
|
/** Append the <code>String</code> to this <code>StringBuffer</code>.
|
|
* @param str the <code>String</code> to append.
|
|
* @return this <code>StringBuffer</code>.
|
|
*/
|
|
public synchronized StringBuffer append (String str)
|
|
{
|
|
if (str == null)
|
|
str = "null";
|
|
int len = str.length();
|
|
ensureCapacity_unsynchronized (count + len);
|
|
str.getChars(0, len, value, count);
|
|
count += len;
|
|
return this;
|
|
}
|
|
|
|
/** Append the <code>char</code> array to this <code>StringBuffer</code>.
|
|
* @param data the <code>char[]</code> to append.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception NullPointerException if <code>str</code> is <code>null</code>.
|
|
*/
|
|
public StringBuffer append (char[] data)
|
|
{
|
|
return append (data, 0, data.length);
|
|
}
|
|
|
|
/** Append the <code>char</code> array to this <code>StringBuffer</code>.
|
|
* @param data the <code>char[]</code> to append.
|
|
* @param offset the place to start grabbing characters from
|
|
* <code>str</code>.
|
|
* @param count the number of characters to get from <code>str</code>.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception NullPointerException if <code>str</code> is <code>null</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> or
|
|
* <code>offset+len</code> is out of range.
|
|
*/
|
|
public synchronized StringBuffer append (char[] data, int offset, int count)
|
|
{
|
|
ensureCapacity_unsynchronized (this.count + count);
|
|
System.arraycopy(data, offset, value, this.count, count);
|
|
this.count += count;
|
|
return this;
|
|
}
|
|
|
|
/** Get the total number of characters this <code>StringBuffer</code>
|
|
* can support before it must be grown. Not to be confused with
|
|
* <em>length</em>.
|
|
* @return the capacity of this <code>StringBuffer</code>
|
|
* @see #length()
|
|
* @see #ensureCapacity(int)
|
|
*/
|
|
public int capacity ()
|
|
{
|
|
return value.length;
|
|
}
|
|
|
|
/** Get the character at the specified index.
|
|
* @param index the index of the character to get, starting at 0.
|
|
* @return the character at the specified index.
|
|
* @exception IndexOutOfBoundsException if the desired character index
|
|
* is negative or greater then length() - 1.
|
|
*/
|
|
public synchronized char charAt (int index)
|
|
{
|
|
if (index >= count)
|
|
throw new StringIndexOutOfBoundsException (index);
|
|
return value[index];
|
|
}
|
|
|
|
/** Delete characters from this <code>StringBuffer</code>.
|
|
* <code>delete(10, 12)</code> will delete 10 and 11, but not 12.
|
|
* @param start the first character to delete.
|
|
* @param end the index after the last character to delete.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception StringIndexOutOfBoundsException if <code>start</code>
|
|
* or <code>end-1</code> are out of bounds, or if
|
|
* <code>start > end</code>.
|
|
*/
|
|
public synchronized StringBuffer delete (int start, int end)
|
|
{
|
|
if (start < 0 || start > count || start > end)
|
|
throw new StringIndexOutOfBoundsException (start);
|
|
if (end > count)
|
|
end = count;
|
|
// This will unshare if required.
|
|
ensureCapacity_unsynchronized (count);
|
|
if (count - end != 0)
|
|
System.arraycopy (value, end, value, start, count - end);
|
|
count -= (end - start);
|
|
return this;
|
|
}
|
|
|
|
/** Delete a character from this <code>StringBuffer</code>.
|
|
* @param index the index of the character to delete.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception StringIndexOutOfBoundsException if <code>index</code>
|
|
* is out of bounds.
|
|
*/
|
|
public StringBuffer deleteCharAt(int index)
|
|
{
|
|
return delete (index, index + 1);
|
|
}
|
|
|
|
/** Increase the capacity of this <code>StringBuffer</code>.
|
|
* This will ensure that an expensive growing operation will not occur
|
|
* until <code>minimumCapacity</code> is reached.
|
|
* If the capacity is actually already greater than <code>minimumCapacity</code>
|
|
* @param minimumCapacity the new capacity.
|
|
* @see #capacity()
|
|
*/
|
|
public synchronized void ensureCapacity (int minimumCapacity)
|
|
{
|
|
if (shared || minimumCapacity > value.length)
|
|
{
|
|
// We don't want to make a larger vector when `shared' is
|
|
// set. If we do, then setLength becomes very inefficient
|
|
// when repeatedly reusing a StringBuffer in a loop.
|
|
int max = (minimumCapacity > value.length
|
|
? value.length*2+2
|
|
: value.length);
|
|
minimumCapacity = (minimumCapacity < max ? max : minimumCapacity);
|
|
char[] nb = new char[minimumCapacity];
|
|
System.arraycopy(value, 0, nb, 0, count);
|
|
value = nb;
|
|
shared = false;
|
|
}
|
|
}
|
|
|
|
// ensureCapacity is used by several synchronized methods in StringBuffer.
|
|
// There's no need to synchronize again.
|
|
private void ensureCapacity_unsynchronized (int minimumCapacity)
|
|
{
|
|
if (shared || minimumCapacity > value.length)
|
|
{
|
|
// We don't want to make a larger vector when `shared' is
|
|
// set. If we do, then setLength becomes very inefficient
|
|
// when repeatedly reusing a StringBuffer in a loop.
|
|
int max = (minimumCapacity > value.length
|
|
? value.length*2+2
|
|
: value.length);
|
|
minimumCapacity = (minimumCapacity < max ? max : minimumCapacity);
|
|
char[] nb = new char[minimumCapacity];
|
|
System.arraycopy(value, 0, nb, 0, count);
|
|
value = nb;
|
|
shared = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the specified array of characters. <code>srcOffset - srcEnd</code>
|
|
* characters will be copied into the array you pass in.
|
|
*
|
|
* @param srcOffset the index to start copying from (inclusive)
|
|
* @param srcEnd the index to stop copying from (exclusive)
|
|
* @param dst the array to copy into
|
|
* @param dstOffset the index to start copying into
|
|
* @throws NullPointerException if dst is null
|
|
* @throws IndexOutOfBoundsException if any source or target indices are
|
|
* out of range (while unspecified, source problems cause a
|
|
* StringIndexOutOfBoundsException, and dest problems cause an
|
|
* ArrayIndexOutOfBoundsException)
|
|
* @see System#arraycopy(Object, int, Object, int, int)
|
|
*/
|
|
public synchronized void getChars(int srcOffset, int srcEnd,
|
|
char[] dst, int dstOffset)
|
|
{
|
|
int todo = srcEnd - srcOffset;
|
|
if (srcOffset < 0 || srcEnd > count || todo < 0)
|
|
throw new StringIndexOutOfBoundsException();
|
|
System.arraycopy(value, srcOffset, dst, dstOffset, todo);
|
|
}
|
|
|
|
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param offset the place to insert.
|
|
* @param bool the <code>boolean</code> to convert and insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(boolean)
|
|
*/
|
|
public StringBuffer insert (int offset, boolean bool)
|
|
{
|
|
return insert (offset, bool ? "true" : "false");
|
|
}
|
|
|
|
/** Insert the <code>char</code> argument into this <code>StringBuffer</code>.
|
|
* @param offset the place to insert.
|
|
* @param ch the <code>char</code> to insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
*/
|
|
public synchronized StringBuffer insert (int offset, char ch)
|
|
{
|
|
if (offset < 0 || offset > count)
|
|
throw new StringIndexOutOfBoundsException (offset);
|
|
ensureCapacity_unsynchronized (count+1);
|
|
System.arraycopy(value, offset, value, offset+1, count-offset);
|
|
value[offset] = ch;
|
|
count++;
|
|
return this;
|
|
}
|
|
|
|
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param offset the place to insert.
|
|
* @param inum the <code>int</code> to convert and insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(int)
|
|
*/
|
|
public StringBuffer insert (int offset, int inum)
|
|
{
|
|
return insert (offset, String.valueOf(inum));
|
|
}
|
|
|
|
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param offset the place to insert.
|
|
* @param lnum the <code>long</code> to convert and insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(long)
|
|
*/
|
|
public StringBuffer insert (int offset, long lnum)
|
|
{
|
|
return insert (offset, String.valueOf(lnum));
|
|
}
|
|
|
|
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param offset the place to insert.
|
|
* @param fnum the <code>float</code> to convert and insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(float)
|
|
*/
|
|
public StringBuffer insert (int offset, float fnum)
|
|
{
|
|
return insert (offset, String.valueOf(fnum));
|
|
}
|
|
|
|
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param offset the place to insert.
|
|
* @param dnum the <code>double</code> to convert and insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(double)
|
|
*/
|
|
public StringBuffer insert (int offset, double dnum)
|
|
{
|
|
return insert (offset, String.valueOf(dnum));
|
|
}
|
|
|
|
/** Insert the <code>String</code> value of the argument into this <code>StringBuffer</code>.
|
|
* Uses <code>String.valueOf()</code> to convert to
|
|
* <code>String</code>.
|
|
* @param offset the place to insert.
|
|
* @param obj the <code>Object</code> to convert and insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
* @see java.lang.String#valueOf(java.lang.Object)
|
|
*/
|
|
public StringBuffer insert (int offset, Object obj)
|
|
{
|
|
return insert (offset, String.valueOf(obj));
|
|
}
|
|
|
|
/** Insert the <code>String</code> argument into this <code>StringBuffer</code>.
|
|
* @param offset the place to insert.
|
|
* @param str the <code>String</code> to insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
*/
|
|
public synchronized StringBuffer insert (int offset, String str)
|
|
{
|
|
if (offset < 0 || offset > count)
|
|
throw new StringIndexOutOfBoundsException (offset);
|
|
// Note that using `null' is from JDK 1.2.
|
|
if (str == null)
|
|
str = "null";
|
|
int len = str.length();
|
|
ensureCapacity_unsynchronized (count+len);
|
|
System.arraycopy(value, offset, value, offset+len, count-offset);
|
|
str.getChars(0, len, value, offset);
|
|
count += len;
|
|
return this;
|
|
}
|
|
|
|
/** Insert the <code>char[]</code> argument into this
|
|
* <code>StringBuffer</code>.
|
|
* @param offset the place to insert.
|
|
* @param data the <code>char[]</code> to insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception NullPointerException if <code>data</code> is
|
|
* <code>null</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range for this <code>StringBuffer</code>.
|
|
*/
|
|
public StringBuffer insert (int offset, char[] data)
|
|
{
|
|
// One could check if offset is invalid here instead of making sure that
|
|
// data isn't null before dereferencing, but this works just as well.
|
|
return insert (offset, data, 0, data == null ? 0 : data.length);
|
|
}
|
|
|
|
/** Insert the <code>char[]</code> argument into this
|
|
* <code>StringBuffer</code>.
|
|
* @param offset the place to insert.
|
|
* @param str the <code>char[]</code> to insert.
|
|
* @param str_offset the index in <code>str</code> to start inserting
|
|
* from.
|
|
* @param len the number of characters to insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
* @exception NullPointerException if <code>str</code> is <code>null</code>.
|
|
* @exception IndexOutOfBoundsException if <code>offset</code> is out
|
|
* of range, for this <code>StringBuffer</code>, or if
|
|
* <code>str_offset</code> or <code>str_offset+len</code>
|
|
* are out of range for <code>str</code>.
|
|
*/
|
|
public synchronized StringBuffer insert(int offset, char[] str,
|
|
int str_offset, int len)
|
|
{
|
|
if (offset < 0 || offset > count)
|
|
throw new StringIndexOutOfBoundsException (offset);
|
|
if (len < 0)
|
|
throw new StringIndexOutOfBoundsException (len);
|
|
if (str_offset < 0 || str_offset + len > str.length)
|
|
throw new StringIndexOutOfBoundsException (str_offset);
|
|
ensureCapacity_unsynchronized (count + len);
|
|
System.arraycopy(value, offset, value, offset + len, count - offset);
|
|
System.arraycopy(str, str_offset, value, offset, len);
|
|
count += len;
|
|
return this;
|
|
}
|
|
|
|
/** Get the length of the <code>String</code> this
|
|
* <code>StringBuffer</code> would create. Not to be confused with the
|
|
* <em>capacity</em> of the <code>StringBuffer</code>.
|
|
* @return the length of this <code>StringBuffer</code>.
|
|
* @see #capacity()
|
|
* @see #setLength(int)
|
|
*/
|
|
public int length ()
|
|
{
|
|
return count;
|
|
}
|
|
|
|
/** Replace characters between index <code>start</code> (inclusive) and
|
|
* <code>end</code> (exclusive) with <code>str</code>. If <code>end</code>
|
|
* is larger than the size of this StringBuffer, all characters after
|
|
* <code>start</code> are replaced.
|
|
* @param start the beginning index of characters to delete (inclusive).
|
|
* @param end the ending index of characters to delete (exclusive).
|
|
* @param str the new <code>String</code> to insert.
|
|
* @return this <code>StringBuffer</code>.
|
|
*/
|
|
public synchronized StringBuffer replace (int start, int end, String str)
|
|
{
|
|
if (start < 0 || start > count || start > end)
|
|
throw new StringIndexOutOfBoundsException (start);
|
|
|
|
int len = str.length();
|
|
// Calculate the difference in 'count' after the replace.
|
|
int delta = len - ((end > count ? count : end) - start);
|
|
ensureCapacity_unsynchronized (count + delta);
|
|
|
|
if (delta != 0 && end < count)
|
|
System.arraycopy(value, end, value, end + delta, count - end);
|
|
|
|
str.getChars (0, len, value, start);
|
|
count += delta;
|
|
return this;
|
|
}
|
|
|
|
/** Reverse the characters in this StringBuffer.
|
|
* @return this <code>StringBuffer</code>.
|
|
*/
|
|
public synchronized StringBuffer reverse ()
|
|
{
|
|
// Call ensureCapacity to enforce copy-on-write.
|
|
ensureCapacity_unsynchronized (count);
|
|
for (int i = 0; i < count / 2; ++i)
|
|
{
|
|
char c = value[i];
|
|
value[i] = value[count - i - 1];
|
|
value[count - i - 1] = c;
|
|
}
|
|
return this;
|
|
}
|
|
|
|
/** Set the character at the specified index.
|
|
* @param index the index of the character to set starting at 0.
|
|
* @param ch the value to set that character to.
|
|
* @exception IndexOutOfBoundsException if the specified character
|
|
* index is not between 0 and length() - 1 (inclusive).
|
|
*/
|
|
public synchronized void setCharAt (int index, char ch)
|
|
{
|
|
if (index < 0 || index >= count)
|
|
throw new StringIndexOutOfBoundsException (index);
|
|
// Call ensureCapacity to enforce copy-on-write.
|
|
ensureCapacity_unsynchronized (count);
|
|
value[index] = ch;
|
|
}
|
|
|
|
/** Set the length of this StringBuffer.
|
|
* <P>
|
|
* If the new length is greater than the current length, all the new
|
|
* characters are set to '\0'.
|
|
* <P>
|
|
* If the new length is less than the current length, the first
|
|
* <code>newLength</code> characters of the old array will be
|
|
* @param newLength the new length
|
|
* @exception IndexOutOfBoundsException if the new length is
|
|
* negative.
|
|
* @see #length()
|
|
*/
|
|
public synchronized void setLength (int newLength)
|
|
{
|
|
if (newLength < 0)
|
|
throw new StringIndexOutOfBoundsException (newLength);
|
|
|
|
ensureCapacity_unsynchronized (newLength);
|
|
for (int i = count; i < newLength; ++i)
|
|
value[i] = '\0';
|
|
count = newLength;
|
|
}
|
|
|
|
/** Create a new StringBuffer with default capacity 16.
|
|
* @see JLS 20.13.1
|
|
*/
|
|
public StringBuffer ()
|
|
{
|
|
this (DEFAULT_CAPACITY);
|
|
}
|
|
|
|
/** Create an empty <code>StringBuffer</code> with the specified initial capacity.
|
|
* @param capacity the initial capacity.
|
|
*/
|
|
public StringBuffer (int capacity)
|
|
{
|
|
count = 0;
|
|
value = new char[capacity];
|
|
shared = false;
|
|
}
|
|
|
|
/** Create a new <code>StringBuffer</code> with the characters in the specified <code>String</code>.
|
|
* Initial capacity will be the size of the String plus 16.
|
|
* @param str the <code>String</code> to make a <code>StringBuffer</code> out of.
|
|
* @XXX optimize for sharing.
|
|
*/
|
|
public StringBuffer (String str)
|
|
{
|
|
// The documentation is not clear, but experimentation with
|
|
// other implementations indicates that StringBuffer(null)
|
|
// should throw a NullPointerException.
|
|
count = str.length();
|
|
// JLS: The initial capacity of the string buffer is 16 plus the
|
|
// length of the argument string.
|
|
value = new char[count + DEFAULT_CAPACITY];
|
|
str.getChars(0, count, value, 0);
|
|
shared = false;
|
|
}
|
|
|
|
/**
|
|
* Creates a substring of this StringBuffer, starting at a specified index
|
|
* and ending at the end of this StringBuffer.
|
|
*
|
|
* @param beginIndex index to start substring (base 0)
|
|
*
|
|
* @return new String which is a substring of this StringBuffer
|
|
*
|
|
* @exception StringIndexOutOfBoundsException
|
|
* if (beginIndex < 0 || beginIndex > this.length())
|
|
*/
|
|
public String substring (int beginIndex)
|
|
{
|
|
return substring (beginIndex, count);
|
|
}
|
|
|
|
/**
|
|
* Creates a substring of this StringBuffer, starting at a specified index
|
|
* and ending at one character before a specified index.
|
|
*
|
|
* @param beginIndex index to start substring (base 0)
|
|
* @param endIndex index after the last character to be
|
|
* copied into the substring
|
|
*
|
|
* @return new String which is a substring of this StringBuffer
|
|
*
|
|
* @exception StringIndexOutOfBoundsException
|
|
* if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex)
|
|
*/
|
|
public synchronized String substring (int beginIndex, int endIndex)
|
|
{
|
|
if (beginIndex < 0 || endIndex > count || beginIndex > endIndex)
|
|
throw new StringIndexOutOfBoundsException ();
|
|
// FIXME: for libgcj it would be possible, and more efficient, to
|
|
// enable sharing here.
|
|
return new String (value, beginIndex, endIndex - beginIndex);
|
|
}
|
|
|
|
/**
|
|
* Creates a substring of this StringBuffer, starting at a specified index
|
|
* and ending at one character before a specified index.
|
|
* <p>
|
|
* To implement <code>CharSequence</code>.
|
|
* Calls <code>substring(beginIndex, endIndex)</code>.
|
|
*
|
|
* @param beginIndex index to start substring (base 0)
|
|
* @param endIndex index after the last character to be
|
|
* copied into the substring
|
|
*
|
|
* @return new String which is a substring of this StringBuffer
|
|
*
|
|
* @exception StringIndexOutOfBoundsException
|
|
* if (beginIndex < 0 || endIndex > this.length() || beginIndex > endIndex)
|
|
*/
|
|
public CharSequence subSequence (int beginIndex, int endIndex)
|
|
{
|
|
return substring(beginIndex, endIndex);
|
|
}
|
|
|
|
|
|
/** Convert this <code>StringBuffer</code> to a <code>String</code>.
|
|
* @return the characters in this StringBuffer
|
|
*/
|
|
public String toString ()
|
|
{
|
|
// Note: in libgcj this causes the StringBuffer to be shared. In
|
|
// Classpath it does not.
|
|
return new String (this);
|
|
}
|
|
|
|
// Index of next available character. Note that this has
|
|
// permissions set this way so that String can get the value.
|
|
int count;
|
|
|
|
// The buffer. Note that this has permissions set this way so that
|
|
// String can get the value.
|
|
char[] value;
|
|
|
|
// True if we need to copy the buffer before writing to it again.
|
|
// FIXME: JDK 1.2 doesn't specify this. The new buffer-growing
|
|
// semantics make this less useful in that case, too. Note that
|
|
// this has permissions set this way so that String can get the
|
|
// value.
|
|
boolean shared;
|
|
|
|
static final long serialVersionUID = 3388685877147921107L;
|
|
private final static int DEFAULT_CAPACITY = 16; // JLS 20.13.1
|
|
}
|