implements java.io.Serializable, Comparable<String>, CharSequence

{

/** The value is used for character storage. */

private final char value[];

/** The offset is the first index of the storage that is used. */

private final int offset;

/** The count is the number of characters in the String. */

private final int count;

/** Cache the hash code for the string */

private int hash; // Default to 0

/** use serialVersionUID from JDK 1.0.2 for interoperability */

private static final long serialVersionUID = -6849794470754667710L;

/**

private static final ObjectStreamField[] serialPersistentFields =

new ObjectStreamField[0];

/**

public String() {

this.offset = 0;

this.count = 0;

this.value = new char[0];

}

/**

public String(String original) {

int size = original.count;

char[] originalValue = original.value;

char[] v;

if (originalValue.length > size) {

// The array representing the String is bigger than the new

// String itself. Perhaps this constructor is being called

// in order to trim the baggage, so make a copy of the array.

int off = original.offset;

v = Arrays.copyOfRange(originalValue, off, off+size);

} else {

// The array representing the String is the same

// size as the String, so no point in making a copy.

v = originalValue;

}

this.offset = 0;

this.count = size;

this.value = v;

}

/**

public String(char value[]) {

int size = value.length;

this.offset = 0;

this.count = size;

this.value = Arrays.copyOf(value, size);

}

/**

public String(char value[], int offset, int count) {

if (offset < 0) {

throw new StringIndexOutOfBoundsException(offset);

}

if (count < 0) {

throw new StringIndexOutOfBoundsException(count);

}

// Note: offset or count might be near -1>>>1.

if (offset > value.length - count) {

throw new StringIndexOutOfBoundsException(offset + count);

}

this.offset = 0;

this.count = count;

this.value = Arrays.copyOfRange(value, offset, offset+count);

}

/**

public String(int[] codePoints, int offset, int count) {

if (offset < 0) {

throw new StringIndexOutOfBoundsException(offset);

}

if (count < 0) {

throw new StringIndexOutOfBoundsException(count);

}

// Note: offset or count might be near -1>>>1.

if (offset > codePoints.length - count) {

throw new StringIndexOutOfBoundsException(offset + count);

}

final int end = offset + count;

// Pass 1: Compute precise size of char[]

int n = count;

for (int i = offset; i < end; i++) {

int c = codePoints[i];

if (Character.isBmpCodePoint(c))

continue;

else if (Character.isValidCodePoint(c))

n++;

else throw new IllegalArgumentException(Integer.toString(c));

}

// Pass 2: Allocate and fill in char[]

final char[] v = new char[n];

for (int i = offset, j = 0; i < end; i++, j++) {

int c = codePoints[i];

if (Character.isBmpCodePoint(c))

v[j] = (char) c;

else

Character.toSurrogates(c, v, j++);

}

this.value = v;

this.count = n;

this.offset = 0;

}

/**

@Deprecated

public String(byte ascii[], int hibyte, int offset, int count) {

checkBounds(ascii, offset, count);

char value[] = new char[count];

if (hibyte == 0) {

for (int i = count ; i-- > 0 ;) {

value[i] = (char) (ascii[i + offset] & 0xff);

}

} else {

hibyte <<= 8;

for (int i = count ; i-- > 0 ;) {

value[i] = (char) (hibyte | (ascii[i + offset] & 0xff));

}

}

this.offset = 0;

this.count = count;

this.value = value;

}

/**

@Deprecated

public String(byte ascii[], int hibyte) {

this(ascii, hibyte, 0, ascii.length);

}

/* Common private utility method used to bounds check the byte array

private static void checkBounds(byte[] bytes, int offset, int length) {

if (length < 0)

throw new StringIndexOutOfBoundsException(length);

if (offset < 0)

throw new StringIndexOutOfBoundsException(offset);

if (offset > bytes.length - length)

throw new StringIndexOutOfBoundsException(offset + length);

}

/**

public String(byte bytes[], int offset, int length, String charsetName)

throws UnsupportedEncodingException

{

if (charsetName == null)

throw new NullPointerException("charsetName");

checkBounds(bytes, offset, length);

char[] v = StringCoding.decode(charsetName, bytes, offset, length);

this.offset = 0;

this.count = v.length;

this.value = v;

}

/**

public String(byte bytes[], int offset, int length, Charset charset) {

if (charset == null)

throw new NullPointerException("charset");

checkBounds(bytes, offset, length);

char[] v = StringCoding.decode(charset, bytes, offset, length);

this.offset = 0;

this.count = v.length;

this.value = v;

}

/**

public String(byte bytes[], String charsetName)

throws UnsupportedEncodingException

{

this(bytes, 0, bytes.length, charsetName);

}

/**

public String(byte bytes[], Charset charset) {

this(bytes, 0, bytes.length, charset);

}

/**

public String(byte bytes[], int offset, int length) {

checkBounds(bytes, offset, length);

char[] v = StringCoding.decode(bytes, offset, length);

this.offset = 0;

this.count = v.length;

this.value = v;

}

/**

public String(byte bytes[]) {

this(bytes, 0, bytes.length);

}

/**

public String(StringBuffer buffer) {

String result = buffer.toString();

this.value = result.value;

this.count = result.count;

this.offset = result.offset;

}

/**

public String(StringBuilder builder) {

String result = builder.toString();

this.value = result.value;

this.count = result.count;

this.offset = result.offset;

}

// Package private constructor which shares value array for speed.

String(int offset, int count, char value[]) {

this.value = value;

this.offset = offset;

this.count = count;

}

/**

public int length() {

return count;

}

/**

public boolean isEmpty() {

return count == 0;

}

/**

public char charAt(int index) {

if ((index < 0) || (index >= count)) {

throw new StringIndexOutOfBoundsException(index);

}

return value[index + offset];

}

/**

public int codePointAt(int index) {

if ((index < 0) || (index >= count)) {

throw new StringIndexOutOfBoundsException(index);

}

return Character.codePointAtImpl(value, offset + index, offset + count);

}

/**

public int codePointBefore(int index) {

int i = index - 1;

if ((i < 0) || (i >= count)) {

throw new StringIndexOutOfBoundsException(index);

}

return Character.codePointBeforeImpl(value, offset + index, offset);

}

/**

public int codePointCount(int beginIndex, int endIndex) {

if (beginIndex < 0 || endIndex > count || beginIndex > endIndex) {

throw new IndexOutOfBoundsException();

}

return Character.codePointCountImpl(value, offset+beginIndex, endIndex-beginIndex);

}

/**

public int offsetByCodePoints(int index, int codePointOffset) {

if (index < 0 || index > count) {

throw new IndexOutOfBoundsException();

}

return Character.offsetByCodePointsImpl(value, offset, count,

offset+index, codePointOffset) - offset;

}

/**

void getChars(char dst[], int dstBegin) {

System.arraycopy(value, offset, dst, dstBegin, count);

}

/**

public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {

if (srcBegin < 0) {

throw new StringIndexOutOfBoundsException(srcBegin);

}

if (srcEnd > count) {

throw new StringIndexOutOfBoundsException(srcEnd);

}

if (srcBegin > srcEnd) {

throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);

}

System.arraycopy(value, offset + srcBegin, dst, dstBegin,

srcEnd - srcBegin);

}

/**

@Deprecated

public void getBytes(int srcBegin, int srcEnd, byte dst[], int dstBegin) {

if (srcBegin < 0) {

throw new StringIndexOutOfBoundsException(srcBegin);

}

if (srcEnd > count) {

throw new StringIndexOutOfBoundsException(srcEnd);

}

if (srcBegin > srcEnd) {

throw new StringIndexOutOfBoundsException(srcEnd - srcBegin);

}

int j = dstBegin;

int n = offset + srcEnd;

int i = offset + srcBegin;

char[] val = value; /* avoid getfield opcode */

while (i < n) {

dst[j++] = (byte)val[i++];

}

}

/**

public byte[] getBytes(String charsetName)

throws UnsupportedEncodingException

{

if (charsetName == null) throw new NullPointerException();

return StringCoding.encode(charsetName, value, offset, count);

}

/**

public byte[] getBytes(Charset charset) {

if (charset == null) throw new NullPointerException();

return StringCoding.encode(charset, value, offset, count);

}

/**

public byte[] getBytes() {

return StringCoding.encode(value, offset, count);

}

/**

public boolean equals(Object anObject) {

if (this == anObject) {

return true;

}

if (anObject instanceof String) {

String anotherString = (String)anObject;

int n = count;

if (n == anotherString.count) {

char v1[] = value;

char v2[] = anotherString.value;

int i = offset;

int j = anotherString.offset;

while (n-- != 0) {

if (v1[i++] != v2[j++])

return false;

}

return true;

}

}

return false;

}

/**

public boolean contentEquals(StringBuffer sb) {

synchronized(sb) {

return contentEquals((CharSequence)sb);

}

}

/**

public boolean contentEquals(CharSequence cs) {

if (count != cs.length())

return false;

// Argument is a StringBuffer, StringBuilder

if (cs instanceof AbstractStringBuilder) {

char v1[] = value;

char v2[] = ((AbstractStringBuilder)cs).getValue();

int i = offset;

int j = 0;

int n = count;

while (n-- != 0) {

if (v1[i++] != v2[j++])

return false;

}

return true;

}

// Argument is a String

if (cs.equals(this))

return true;

// Argument is a generic CharSequence

char v1[] = value;

int i = offset;

int j = 0;

int n = count;

while (n-- != 0) {