From 2238de654fe0eb5e098c7986aaa9148b627ee441 Mon Sep 17 00:00:00 2001 From: Tom Tromey Date: Tue, 9 May 2000 22:46:58 +0000 Subject: StringBuffer.java (toString): Don't mark buffer as shared. * java/lang/StringBuffer.java (toString): Don't mark buffer as shared. (insert(int,char[],int,int): New method. (delete): New method from Classpath. (deleteCharAt): Likewise. (substring): Likewise. (shared): No longer private. Added JavaDoc comments from Classpath. * java/lang/String.java (String(StringBuffer)): Ensure `buffer' is shared. From-SVN: r33809 --- libjava/ChangeLog | 13 + libjava/java/lang/String.java | 6 +- libjava/java/lang/StringBuffer.java | 826 ++++++++++++++++++++++++++---------- 3 files changed, 618 insertions(+), 227 deletions(-) diff --git a/libjava/ChangeLog b/libjava/ChangeLog index 0f6a736..040fd2f 100644 --- a/libjava/ChangeLog +++ b/libjava/ChangeLog @@ -1,3 +1,16 @@ +2000-05-09 Tom Tromey + + * java/lang/StringBuffer.java (toString): Don't mark buffer as + shared. + (insert(int,char[],int,int): New method. + (delete): New method from Classpath. + (deleteCharAt): Likewise. + (substring): Likewise. + (shared): No longer private. + Added JavaDoc comments from Classpath. + * java/lang/String.java (String(StringBuffer)): Ensure `buffer' is + shared. + 2000-05-07 Tom Tromey * Makefile.in: Rebuilt. diff --git a/libjava/java/lang/String.java b/libjava/java/lang/String.java index 7ab96f4..54be314 100644 --- a/libjava/java/lang/String.java +++ b/libjava/java/lang/String.java @@ -38,7 +38,11 @@ public final class String public String (StringBuffer buffer) { - init (buffer.value, 0, buffer.count, true); + synchronized (buffer) + { + buffer.shared = true; + init (buffer.value, 0, buffer.count, true); + } } public String (char[] data) diff --git a/libjava/java/lang/StringBuffer.java b/libjava/java/lang/StringBuffer.java index 4034e79..15f6271 100644 --- a/libjava/java/lang/StringBuffer.java +++ b/libjava/java/lang/StringBuffer.java @@ -17,277 +17,651 @@ 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. */ +/** + * StringBuffer represents a changeable String. + * It provides the operations required to modify the + * StringBuffer including insert, replace, delete, append, + * and reverse. + *

+ * + * StringBuffers are variable-length in nature, so even if + * you initialize them to a certain size, they can still grow larger than + * that. Capacity indicates the number of characters the + * StringBuffer can have in it before it has to grow (growing + * the char array is an expensive operation involving new). + *

+ * + * Incidentally, the String operator "+" actually is turned into a + * StringBuffer operation: + *
+ * a + b + *
+ * is the same as + *
+ * new StringBuffer(a).append(b).toString(). + * + * @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 { + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param bool the boolean to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(boolean) + */ public StringBuffer append (boolean bool) - { - return append (String.valueOf(bool)); - } - + { + return append (String.valueOf(bool)); + } + + /** Append the char to this StringBuffer. + * @param c the char to append. + * @return this StringBuffer. + */ public synchronized StringBuffer append (char ch) - { - ensureCapacity_unsynchronized (count + 1); - value[count++] = ch; - return this; - } - + { + ensureCapacity_unsynchronized (count + 1); + value[count++] = ch; + return this; + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param inum the int to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(int) + */ public StringBuffer append (int inum) - { - return append (String.valueOf(inum)); - } - + { + return append (String.valueOf(inum)); + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param lnum the long to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(long) + */ public StringBuffer append (long lnum) - { - return append (String.valueOf(lnum)); - } - + { + return append (String.valueOf(lnum)); + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param fnum the float to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(float) + */ public StringBuffer append (float fnum) - { - return append (String.valueOf(fnum)); - } - + { + return append (String.valueOf(fnum)); + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param dnum the double to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(double) + */ public StringBuffer append (double dnum) - { - return append (String.valueOf(dnum)); - } - + { + return append (String.valueOf(dnum)); + } + + /** Append the String value of the argument to this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param obj the Object to convert and append. + * @return this StringBuffer. + * @see java.lang.String#valueOf(java.lang.Object) + */ public StringBuffer append (Object obj) - { - return append (String.valueOf(obj)); - } - + { + return append (String.valueOf(obj)); + } + + /** Append the String to this StringBuffer. + * @param str the String to append. + * @return this StringBuffer. + */ 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; - } - + { + 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 char array to this StringBuffer. + * @param data the char[] to append. + * @return this StringBuffer. + * @exception NullPointerException if str is null. + */ public StringBuffer append (char[] data) - { - return append (data, 0, data.length); - } - + { + return append (data, 0, data.length); + } + + /** Append the char array to this StringBuffer. + * @param data the char[] to append. + * @param offset the place to start grabbing characters from + * str. + * @param count the number of characters to get from str. + * @return this StringBuffer. + * @exception NullPointerException if str is null. + * @exception IndexOutOfBoundsException if offset or + * offset+len 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; - } - + { + 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 StringBuffer + * can support before it must be grown. Not to be confused with + * length. + * @return the capacity of this StringBuffer + * @see #length() + * @see #ensureCapacity(int) + */ public int capacity () - { - return value.length; - } - + { + 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 not between 0 and length() - 1 (inclusive). + */ public synchronized char charAt (int index) - { - if (index >= count) - throw new StringIndexOutOfBoundsException (index); - return value[index]; - } - + { + if (index >= count) + throw new StringIndexOutOfBoundsException (index); + return value[index]; + } + + /** Delete characters from this StringBuffer. + * delete(10, 12) 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 StringBuffer. + * @exception StringIndexOutOfBoundsException if start + * or end-1 are out of bounds, or if + * start > end. + */ + 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); + count -= (end - start); + System.arraycopy (value, end - 1, value, start, end - start); + return this; + } + + /** Delete a character from this StringBuffer. + * @param index the index of the character to delete. + * @return this StringBuffer. + * @exception StringIndexOutOfBoundsException if index + * is out of bounds. + */ + public StringBuffer deleteCharAt(int index) + { + return delete (index, index + 1); + } + + /** Increase the capacity of this StringBuffer. + * This will ensure that an expensive growing operation will not occur + * until minimumCapacity is reached. + * If the capacity is actually already greater than minimumCapacity + * @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; - } - } + { + 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; - } - } - + { + 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. + * The characters will be copied into the array you pass in. + * @param srcOffset the index to start copying from in the + * StringBuffer. + * @param srcEnd the number of characters to copy. + * @param dst the array to copy into. + * @param dstOffset the index to start copying into dst. + * @exception NullPointerException if dst is null. + * @exception IndexOutOfBoundsException if any source or target + * indices are out of range. + * @see java.lang.System#arrayCopy(java.lang.Object,int,java.lang.Object,int,int) + */ public synchronized void getChars (int srcOffset, int srcEnd, char[] dst, int dstOffset) - { - if (srcOffset < 0 || srcOffset > srcEnd) - throw new StringIndexOutOfBoundsException (srcOffset); - int todo = srcEnd - srcOffset; - if (srcEnd > count || dstOffset + todo > count) - throw new StringIndexOutOfBoundsException (srcEnd); - System.arraycopy(value, srcOffset, dst, dstOffset, todo); - } - + { + if (srcOffset < 0 || srcOffset > srcEnd) + throw new StringIndexOutOfBoundsException (srcOffset); + int todo = srcEnd - srcOffset; + if (srcEnd > count || dstOffset + todo > count) + throw new StringIndexOutOfBoundsException (srcEnd); + System.arraycopy(value, srcOffset, dst, dstOffset, todo); + } + + /** Insert the String value of the argument into this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param offset the place to insert. + * @param bool the boolean to convert and insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + * @see java.lang.String#valueOf(boolean) + */ public StringBuffer insert (int offset, boolean bool) - { - return insert (offset, bool ? "true" : "false"); - } - + { + return insert (offset, bool ? "true" : "false"); + } + + /** Insert the char argument into this StringBuffer. + * @param offset the place to insert. + * @param ch the char to insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + */ 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; - } - + { + 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 String value of the argument into this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param offset the place to insert. + * @param inum the int to convert and insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + * @see java.lang.String#valueOf(int) + */ public StringBuffer insert (int offset, int inum) - { - return insert (offset, String.valueOf(inum)); - } - + { + return insert (offset, String.valueOf(inum)); + } + + /** Insert the String value of the argument into this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param offset the place to insert. + * @param lnum the long to convert and insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + * @see java.lang.String#valueOf(long) + */ public StringBuffer insert (int offset, long lnum) - { - return insert (offset, String.valueOf(lnum)); - } - + { + return insert (offset, String.valueOf(lnum)); + } + + /** Insert the String value of the argument into this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param offset the place to insert. + * @param fnum the float to convert and insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + * @see java.lang.String#valueOf(float) + */ public StringBuffer insert (int offset, float fnum) - { - return insert (offset, String.valueOf(fnum)); - } - + { + return insert (offset, String.valueOf(fnum)); + } + + /** Insert the String value of the argument into this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param offset the place to insert. + * @param dnum the double to convert and insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + * @see java.lang.String#valueOf(double) + */ public StringBuffer insert (int offset, double dnum) - { - return insert (offset, String.valueOf(dnum)); - } - + { + return insert (offset, String.valueOf(dnum)); + } + + /** Insert the String value of the argument into this StringBuffer. + * Uses String.valueOf() to convert to + * String. + * @param offset the place to insert. + * @param obj the Object to convert and insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + * @see java.lang.String#valueOf(java.lang.Object) + */ public StringBuffer insert (int offset, Object obj) - { - return insert (offset, String.valueOf(obj)); - } - + { + return insert (offset, String.valueOf(obj)); + } + + /** Insert the String argument into this StringBuffer. + * @param offset the place to insert. + * @param str the String to insert. + * @return this StringBuffer. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + */ 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; - } - - public synchronized StringBuffer insert (int offset, char[] data) - { - if (offset < 0 || offset > count) - throw new StringIndexOutOfBoundsException (offset); - int len = data.length; - ensureCapacity_unsynchronized (count+len); - System.arraycopy(value, offset, value, offset+len, count-offset); - System.arraycopy(data, 0, value, offset, len); - count += len; - return this; - } - + { + 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 char[] argument into this + * StringBuffer. + * @param offset the place to insert. + * @param data the char[] to insert. + * @return this StringBuffer. + * @exception NullPointerException if data is + * null. + * @exception IndexOutOfBoundsException if offset is out + * of range for this StringBuffer. + */ + public StringBuffer insert (int offset, char[] data) + { + return insert (offset, data, 0, data.length); + } + + /** Insert the char[] argument into this + * StringBuffer. + * @param offset the place to insert. + * @param str the char[] to insert. + * @param str_offset the index in str to start inserting + * from. + * @param len the number of characters to insert. + * @return this StringBuffer. + * @exception NullPointerException if str is null. + * @exception IndexOutOfBoundsException if offset is out + * of range, for this StringBuffer, or if + * str_offset or str_offset+len + * are out of range for str. + */ + 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 String this + * StringBuffer would create. Not to be confused with the + * capacity of the StringBuffer. + * @return the length of this StringBuffer. + * @see #capacity() + * @see #setLength() + */ public int length () - { - return count; - } - + { + return count; + } + + /** Delete a character from this StringBuffer. + * @param index the index of the character to delete. + * @return this StringBuffer. + * @exception StringIndexOutOfBoundsException if index + * is out of bounds. + */ + public synchronized StringBuffer replace (int start, int end, String str) + { + // FIXME: this is inefficient. + delete (start, end); + return insert (start, str); + } + + /** Reverse the characters in this StringBuffer. + * @return this StringBuffer. + */ public synchronized StringBuffer reverse () - { - 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; - } - + { + 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; - } - + { + 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. + *

+ * If the new length is greater than the current length, all the new + * characters are set to '\0'. + *

+ * If the new length is less than the current length, the first + * newLength 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; - } - + { + 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 (16); - } + { + this (DEFAULT_CAPACITY); + } + /** Create an empty StringBuffer with the specified initial capacity. + * @param capacity the initial capacity. + */ public StringBuffer (int capacity) - { - count = 0; - value = new char[capacity]; - shared = false; - } - + { + count = 0; + value = new char[capacity]; + shared = false; + } + + /** Create a new StringBuffer with the characters in the specified String. + * Initial capacity will be the size of the String plus 16. + * @param str the String to make a StringBuffer 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 + 16]; - str.getChars(0, count, value, 0); - shared = false; - } - + { + // 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 + 16]; + 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); + } + + /** Convert this StringBuffer to a String. + * @return the characters in this StringBuffer + */ public String toString () - { - shared = true; - return new String (this); - } - - // The buffer. Note that this has permissions set this way so that - // String can get the value. - char[] value; + { + // 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. - private boolean shared; + // 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 } -- cgit v1.1