AbstractStringBuilderpublic abstract class AbstractStringBuilder extends Object
A modifiable {@link CharSequence sequence of characters} for use in creating
and modifying Strings. This class is intended as a base class for
{@link StringBuffer} and {@link StringBuilder}.
|
| Fields Summary |
|---|
| static final int | INITIAL_CAPACITY | | private char[] | value | | private int | count | | private boolean | shared |
| Constructors Summary |
|---|
AbstractStringBuilder()
value = new char[INITIAL_CAPACITY];
| AbstractStringBuilder(int capacity)
if (capacity < 0) {
throw new NegativeArraySizeException();
}
value = new char[capacity];
| AbstractStringBuilder(String string)
count = string.length();
shared = false;
value = new char[count + INITIAL_CAPACITY];
// BEGIN android-changed
string._getChars(0, count, value, 0);
// END android-changed
|
| Methods Summary |
|---|
| final void | append0(char[] chars, int start, int length)
if (chars == null) {
throw new NullPointerException();
}
// start + length could overflow, start/length maybe MaxInt
if (start >= 0 && 0 <= length && length <= chars.length - start) {
int newSize = count + length;
if (newSize > value.length) {
enlargeBuffer(newSize);
} else if (shared) {
value = value.clone();
shared = false;
}
System.arraycopy(chars, start, value, count, length);
count = newSize;
} else {
throw new ArrayIndexOutOfBoundsException();
}
| | final void | append0(char ch)
if (count == value.length) {
enlargeBuffer(count + 1);
}
if (shared) {
value = value.clone();
shared = false;
}
value[count++] = ch;
| | final void | append0(java.lang.String string)
if (string == null) {
appendNull();
return;
}
int adding = string.length();
int newSize = count + adding;
if (newSize > value.length) {
enlargeBuffer(newSize);
} else if (shared) {
value = value.clone();
shared = false;
}
// BEGIN android-changed
string._getChars(0, adding, value, count);
// END android-changed
count = newSize;
| | final void | append0(java.lang.CharSequence s, int start, int end)
if (s == null) {
s = "null"; //$NON-NLS-1$
}
if (start < 0 || end < 0 || start > end || end > s.length()) {
throw new IndexOutOfBoundsException();
}
// BEGIN android-changed
int adding = end - start;
int newSize = count + adding;
if (newSize > value.length) {
enlargeBuffer(newSize);
} else if (shared) {
value = value.clone();
shared = false;
}
if (s instanceof String) {
// BEGIN android-changed
((String) s)._getChars(start, end, value, count);
// END android-changed
} else {
int j = count; // Destination index.
for (int i = start; i < end; i++) {
value[j++] = s.charAt(i);
}
}
this.count = newSize;
// END android-changed
| | final void | append0(char[] chars)
int newSize = count + chars.length;
if (newSize > value.length) {
enlargeBuffer(newSize);
} else if (shared) {
value = value.clone();
shared = false;
}
System.arraycopy(chars, 0, value, count, chars.length);
count = newSize;
| | final void | appendNull()
int newSize = count + 4;
if (newSize > value.length) {
enlargeBuffer(newSize);
} else if (shared) {
value = value.clone();
shared = false;
}
value[count++] = 'n";
value[count++] = 'u";
value[count++] = 'l";
value[count++] = 'l";
| | public int | capacity()Returns the number of characters that can be held without growing.
return value.length;
| | public char | charAt(int index)Retrieves the character at the {@code index}.
if (index < 0 || index >= count) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
| | public int | codePointAt(int index)Retrieves the Unicode code point value at the {@code index}.
if (index < 0 || index >= count) {
throw new StringIndexOutOfBoundsException(index);
}
return Character.codePointAt(value, index, count);
| | public int | codePointBefore(int index)Retrieves the Unicode code point value that precedes the {@code index}.
if (index < 1 || index > count) {
throw new StringIndexOutOfBoundsException(index);
}
return Character.codePointBefore(value, index);
| | public int | codePointCount(int beginIndex, int endIndex)
Calculates the number of Unicode code points between {@code beginIndex}
and {@code endIndex}.
if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) {
throw new StringIndexOutOfBoundsException();
}
return Character.codePointCount(value, beginIndex, endIndex
- beginIndex);
| | final void | delete0(int start, int end)
if (start >= 0) {
if (end > count) {
end = count;
}
if (end == start) {
return;
}
if (end > start) {
int length = count - end;
if (length > 0) {
if (!shared) {
System.arraycopy(value, end, value, start, length);
} else {
char[] newData = new char[value.length];
System.arraycopy(value, 0, newData, 0, start);
System.arraycopy(value, end, newData, start, length);
value = newData;
shared = false;
}
}
count -= end - start;
return;
}
}
throw new StringIndexOutOfBoundsException();
| | final void | deleteCharAt0(int location)
if (0 > location || location >= count) {
throw new StringIndexOutOfBoundsException(location);
}
int length = count - location - 1;
if (length > 0) {
if (!shared) {
System.arraycopy(value, location + 1, value, location, length);
} else {
char[] newData = new char[value.length];
System.arraycopy(value, 0, newData, 0, location);
System
.arraycopy(value, location + 1, newData, location,
length);
value = newData;
shared = false;
}
}
count--;
| | private void | enlargeBuffer(int min)
int twice = (value.length << 1) + 2;
char[] newData = new char[min > twice ? min : twice];
System.arraycopy(value, 0, newData, 0, count);
value = newData;
shared = false;
| | public void | ensureCapacity(int min)Ensures that this object has a minimum capacity available before
requiring the internal buffer to be enlarged. The general policy of this
method is that if the {@code minimumCapacity} is larger than the current
{@link #capacity()}, then the capacity will be increased to the largest
value of either the {@code minimumCapacity} or the current capacity
multiplied by two plus two. Although this is the general policy, there is
no guarantee that the capacity will change.
if (min > value.length) {
enlargeBuffer(min);
}
| | public void | getChars(int start, int end, char[] dest, int destStart)Copies the requested sequence of characters to the {@code char[]} passed
starting at {@code destStart}.
if (start > count || end > count || start > end) {
throw new StringIndexOutOfBoundsException();
}
System.arraycopy(value, start, dest, destStart, end - start);
| | final char[] | getValue()
/*
* Returns the character array.
*/
return value;
| | public int | indexOf(java.lang.String string)Searches for the first index of the specified character. The search for
the character starts at the beginning and moves towards the end.
return indexOf(string, 0);
| | public int | indexOf(java.lang.String subString, int start)Searches for the index of the specified character. The search for the
character starts at the specified offset and moves towards the end.
if (start < 0) {
start = 0;
}
int subCount = subString.length();
if (subCount > 0) {
if (subCount + start > count) {
return -1;
}
// TODO optimize charAt to direct array access
char firstChar = subString.charAt(0);
while (true) {
int i = start;
boolean found = false;
for (; i < count; i++) {
if (value[i] == firstChar) {
found = true;
break;
}
}
if (!found || subCount + i > count) {
return -1; // handles subCount > count || start >= count
}
int o1 = i, o2 = 0;
while (++o2 < subCount && value[++o1] == subString.charAt(o2)) {
// Intentionally empty
}
if (o2 == subCount) {
return i;
}
start = i + 1;
}
}
return (start < count || start == 0) ? start : count;
| | final void | insert0(int index, char[] chars)
if (0 > index || index > count) {
throw new StringIndexOutOfBoundsException(index);
}
if (chars.length != 0) {
move(chars.length, index);
System.arraycopy(chars, 0, value, index, chars.length);
count += chars.length;
}
| | final void | insert0(int index, char[] chars, int start, int length)
if (0 <= index && index <= count) {
// start + length could overflow, start/length maybe MaxInt
if (start >= 0 && 0 <= length && length <= chars.length - start) {
if (length != 0) {
move(length, index);
System.arraycopy(chars, start, value, index, length);
count += length;
}
return;
}
throw new StringIndexOutOfBoundsException("offset " + start
+ ", len " + length + ", array.length " + chars.length);
}
throw new StringIndexOutOfBoundsException(index);
| | final void | insert0(int index, char ch)
if (0 > index || index > count) {
// RI compatible exception type
throw new ArrayIndexOutOfBoundsException(index);
}
move(1, index);
value[index] = ch;
count++;
| | final void | insert0(int index, java.lang.String string)
if (0 <= index && index <= count) {
if (string == null) {
string = "null"; //$NON-NLS-1$
}
int min = string.length();
if (min != 0) {
move(min, index);
// BEGIN android-changed
string._getChars(0, min, value, index);
// END android-changed
count += min;
}
} else {
throw new StringIndexOutOfBoundsException(index);
}
| | final void | insert0(int index, java.lang.CharSequence s, int start, int end)
if (s == null) {
s = "null"; //$NON-NLS-1$
}
if (index < 0 || index > count || start < 0 || end < 0 || start > end
|| end > s.length()) {
throw new IndexOutOfBoundsException();
}
insert0(index, s.subSequence(start, end).toString());
| | public int | lastIndexOf(java.lang.String string)Searches for the last index of the specified character. The search for
the character starts at the end and moves towards the beginning.
return lastIndexOf(string, count);
| | public int | lastIndexOf(java.lang.String subString, int start)Searches for the index of the specified character. The search for the
character starts at the specified offset and moves towards the beginning.
int subCount = subString.length();
if (subCount <= count && start >= 0) {
if (subCount > 0) {
if (start > count - subCount) {
start = count - subCount; // count and subCount are both
}
// >= 1
// TODO optimize charAt to direct array access
char firstChar = subString.charAt(0);
while (true) {
int i = start;
boolean found = false;
for (; i >= 0; --i) {
if (value[i] == firstChar) {
found = true;
break;
}
}
if (!found) {
return -1;
}
int o1 = i, o2 = 0;
while (++o2 < subCount
&& value[++o1] == subString.charAt(o2)) {
// Intentionally empty
}
if (o2 == subCount) {
return i;
}
start = i - 1;
}
}
return start < count ? start : count;
}
return -1;
| | public int | length()The current length.
return count;
| | private void | move(int size, int index)
int newSize;
if (value.length - count >= size) {
if (!shared) {
System.arraycopy(value, index, value, index + size, count
- index); // index == count case is no-op
return;
}
newSize = value.length;
} else {
int a = count + size, b = (value.length << 1) + 2;
newSize = a > b ? a : b;
}
char[] newData = new char[newSize];
System.arraycopy(value, 0, newData, 0, index);
// index == count case is no-op
System.arraycopy(value, index, newData, index + size, count - index);
value = newData;
shared = false;
| | public int | offsetByCodePoints(int index, int codePointOffset)
Returns the index that is offset {@code codePointOffset} code points from
{@code index}.
return Character.offsetByCodePoints(value, 0, count, index,
codePointOffset);
| | final void | replace0(int start, int end, java.lang.String string)
if (start >= 0) {
if (end > count) {
end = count;
}
if (end > start) {
int stringLength = string.length();
int diff = end - start - stringLength;
if (diff > 0) { // replacing with fewer characters
if (!shared) {
// index == count case is no-op
System.arraycopy(value, end, value, start
+ stringLength, count - end);
} else {
char[] newData = new char[value.length];
System.arraycopy(value, 0, newData, 0, start);
// index == count case is no-op
System.arraycopy(value, end, newData, start
+ stringLength, count - end);
value = newData;
shared = false;
}
} else if (diff < 0) {
// replacing with more characters...need some room
move(-diff, end);
} else if (shared) {
value = value.clone();
shared = false;
}
// BEGIN android-changed
string._getChars(0, stringLength, value, start);
// END android-changed
count -= diff;
return;
}
if (start == end) {
if (string == null) {
throw new NullPointerException();
}
insert0(start, string);
return;
}
}
throw new StringIndexOutOfBoundsException();
| | final void | reverse0()
if (count < 2) {
return;
}
if (!shared) {
for (int i = 0, end = count, mid = count / 2; i < mid; i++) {
char temp = value[--end];
value[end] = value[i];
value[i] = temp;
}
} else {
char[] newData = new char[value.length];
for (int i = 0, end = count; i < count; i++) {
newData[--end] = value[i];
}
value = newData;
shared = false;
}
| | final void | set(char[] val, int len)
if (val == null) {
val = new char[0];
}
if (val.length < len) {
throw new InvalidObjectException(Msg.getString("K0199")); //$NON-NLS-1$
}
shared = false;
value = val;
count = len;
| | public void | setCharAt(int index, char ch)Sets the character at the {@code index}.
if (0 > index || index >= count) {
throw new StringIndexOutOfBoundsException(index);
}
if (shared) {
value = value.clone();
shared = false;
}
value[index] = ch;
| | public void | setLength(int length)Sets the current length to a new value. If the new length is larger than
the current length, then the new characters at the end of this object
will contain the {@code char} value of {@code \u0000}.
if (length < 0) {
throw new StringIndexOutOfBoundsException(length);
}
if (count < length) {
if (length > value.length) {
enlargeBuffer(length);
} else {
if (shared) {
char[] newData = new char[value.length];
System.arraycopy(value, 0, newData, 0, count);
value = newData;
shared = false;
} else {
Arrays.fill(value, count, length, (char) 0);
}
}
}
count = length;
| | final char[] | shareValue()
shared = true;
return value;
| | public java.lang.CharSequence | subSequence(int start, int end)Returns a {@code CharSequence} of the subsequence from the {@code start}
index to the {@code end} index.
return substring(start, end);
| | public java.lang.String | substring(int start)Returns the String value of the subsequence from the {@code start} index
to the current end.
if (0 <= start && start <= count) {
if (start == count) {
return ""; //$NON-NLS-1$
}
shared = true;
return new String(start, count - start, value);
}
throw new StringIndexOutOfBoundsException(start);
| | public java.lang.String | substring(int start, int end)Returns the String value of the subsequence from the {@code start} index
to the {@code end} index.
if (0 <= start && start <= end && end <= count) {
if (start == end) {
return ""; //$NON-NLS-1$
}
shared = true;
return new String(value, start, end - start);
}
throw new StringIndexOutOfBoundsException();
| | public java.lang.String | toString()Returns the current String representation.
if (count == 0) {
return ""; //$NON-NLS-1$
}
if (count >= 256 && count <= (value.length >> 1)) {
return new String(value, 0, count);
}
shared = true;
return new String(0, count, value);
| | public void | trimToSize()Trims off any extra capacity beyond the current length. Note, this method
is NOT guaranteed to change the capacity of this object.
if (count < value.length) {
char[] newValue = new char[count];
System.arraycopy(value, 0, newValue, 0, count);
value = newValue;
shared = false;
}
|
|
