stringbuffer.java

一个开源的JAVA虚拟机

/*
    libaegisvm - The Aegis Virtual Machine for executing Java bytecode
    Modifications by Philip W. L. Fong
    Copyright (C) 2001-2002  

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

// (C) 1996 Glynn Clements <[e-mail]> - Freely Redistributable

package java.lang;

/**
 * \todo Optimization: copy on write.
 */
public final class StringBuffer implements java.io.Serializable {
    char[] data;
    int length;	// actual used bytes in the string

    public StringBuffer() {
	this(16);
    }
    public StringBuffer(int length) {
	data = new char[length];
	this.length = 0;
    }
    public StringBuffer(String str) {
	length = str.value.length;
	data = new char[length + 16];
	for (int i = 0; i < length; i++)
	    data[i] = str.value[i];
    }

    public int length() {
	return length;
    }
    public int capacity() {
	return data.length;
    }
    public void ensureCapacity(int minimumCapacity) {
	if (data.length >= minimumCapacity)
	    return;
	int n;
	char[] buff;
	n = data.length * 2 + 2;
	if (n < minimumCapacity)
	    n = minimumCapacity;
	buff = new char[n];
	for (int i = 0; i < length; i++)
	    buff[i] = data[i];
	data = buff;
    }
    public void setLength(int newLength) {
	if (newLength < 0)
	    throw new StringIndexOutOfBoundsException();
	ensureCapacity(newLength);
	for (int i = length; i < newLength; i++)
	    data[i] = '\u0000';
	length = newLength;
    }
    public char charAt(int index) {
	if (index < 0 || index >= length)
	    throw new StringIndexOutOfBoundsException();
	return data[index];
    }
    public void getChars(int srcBegin,
			 int srcEnd,
			 char[] dst,
			 int dstBegin) {
	if (srcBegin < 0 ||
	    dstBegin < 0 ||
	    srcBegin > srcEnd ||
	    srcEnd > length ||
	    srcEnd - srcBegin > dst.length - dstBegin)
	    throw new StringIndexOutOfBoundsException();

	for (int i = srcBegin, j = dstBegin; i < srcEnd; ++i, ++j)
	    dst[j] = data[i];
    }
    public void setCharAt(int index, char ch) {
	if (index < 0 || index >= length)
	    throw new StringIndexOutOfBoundsException();
	data[index] = ch;
    }
    public StringBuffer append(Object o) {
	return append(String.valueOf(o));
    }
    public StringBuffer append(String str) {
	if (str == null)
	    return append("null");
	return append(str.value);
    }
    public StringBuffer append(char[] str) {
	return append(str, 0, str.length);
    }
    public StringBuffer append(char[] str, int offset, int len) {
	if (offset < 0 ||
	    offset > str.length ||
	    len < 0 ||
	    len > str.length ||
	    str.length - offset < len)
	    throw new StringIndexOutOfBoundsException();
	ensureCapacity(length + len);
	for (int i = length, j = offset; j < offset + len; i++, j++)
	    data[i] = str[j];
	length += len;
	return this;
    }
    public StringBuffer append(boolean b) {
	return append(String.valueOf(b));
    }
    public StringBuffer append(char c) {
	return append(String.valueOf(c));
    }
    public StringBuffer append(int i) {
	return append(String.valueOf(i));
    }
    public StringBuffer append(long l) {
	return append(String.valueOf(l));
    }
    public StringBuffer append(float f) {
	return append(String.valueOf(f));
    }
    public StringBuffer append(double d) {
	return append(String.valueOf(d));
    }
    public StringBuffer delete(int start, int end) {
	if (start < 0 ||
	    start > length ||
	    start > end)
	    throw new StringIndexOutOfBoundsException();
	if (end > length)
	    end = length;
	for (int i = start, j = end; j < length; i++, j++)
	    data[i] = data[j];
	length -= (end - start);
	return this;
    }
    public StringBuffer deleteCharAt(int index) {
	return delete(index, index+1);
    }
    public StringBuffer replace(int start, int end, String str) {
	return delete(start, end).insert(start, str);
    }
    public String substring(int start) {
	return substring(start, length);
    }
    public String substring(int start, int end) {
	if (start < 0 ||
	    start > length ||
	    end < 0 ||
	    end > length ||
	    start > end)
	    throw new StringIndexOutOfBoundsException();
	return new String(data, start, end - start);
    }
    public StringBuffer insert(int offset, Object o) {
	return insert(offset, String.valueOf(o));
    }
    public StringBuffer insert(int offset, char[] str) {
	if (offset < 0 || offset > length)
	    throw new StringIndexOutOfBoundsException();
	int n = str.length;
	ensureCapacity(length + n);
	for (int i = length - 1; i >= offset; i--)
	    data[i+n] = data[i];
	for (int i = 0; i < n; i++)
	    data[offset + i] = str[i];
	length += n;
	return this;
    }
    public StringBuffer insert(int offset, String str) {
	if (str == null)
	    return insert(offset, "null");
	return insert(offset, str.value);
    }
    public StringBuffer insert(int offset, boolean b) {
	return insert(offset, String.valueOf(b));
    }
    public StringBuffer insert(int offset, char c) {
	return insert(offset, String.valueOf(c));
    }
    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 StringBuffer reverse() {
	for (int i = 0; i < length / 2; i++) {
	    int j = length - 1 - i;
	    char tmp = data[i];
	    data[i] = data[j];
	    data[j] = tmp;
	}
	return this;
    }
    public String toString() {
	return new String(data, 0, length);
    }
}