String

public final class String

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

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

    private final char value[];

 

    /** 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.value = "".value;

    }

 

    public String(String original) {

        this.value = original.value;

        this.hash = original.hash;

    }

 

    public String(char value[]) {

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

    }

 

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

        if (offset < 0) {

            throw new StringIndexOutOfBoundsException(offset);

        }

        if (count <= 0) {

            if (count < 0) {

                throw new StringIndexOutOfBoundsException(count);

            }

            if (offset <= value.length) {

                this.value = "".value;

                return;

            }

        }

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

        if (offset > value.length - count) {

            throw new StringIndexOutOfBoundsException(offset + 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) {

            if (count < 0) {

                throw new StringIndexOutOfBoundsException(count);

            }

            if (offset <= codePoints.length) {

                this.value = "".value;

                return;

            }

        }

        // 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;

    }

 

    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);

        this.value = StringCoding.decode(charsetName, bytes, offset, length);

    }

 

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

        if (charset == null)

            throw new NullPointerException("charset");

        checkBounds(bytes, offset, length);

        this.value =  StringCoding.decode(charset, bytes, offset, length);

    }

 

    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);

        this.value = StringCoding.decode(bytes, offset, length);

    }

 

    public String(byte bytes[]) {

        this(bytes, 0, bytes.length);

    }

 

    public String(StringBuffer buffer) {

        synchronized(buffer) {

            this.value = Arrays.copyOf(buffer.getValue(), buffer.length());

        }

    }

 

    public String(StringBuilder builder) {

        this.value = Arrays.copyOf(builder.getValue(), builder.length());

    }

 

    String(char[] value, boolean share) {

        // assert share : "unshared not supported";

        this.value = value;

    }

 

    public int length() {

        return value.length;

    }

 

    public boolean isEmpty() {

        return value.length == 0;

    }

}